#ifndef _CallpAsnTypes_h_
#define _CallpAsnTypes_h_
////////////////////////////////////////////////////////////////////////////////
/// @file CallpAsnTypes.h
/// @brief This file contains all the common ASN types for callp and layer 2.
///
/// Maintained by: LTE eNB Callp Application Team
///
/// Copyright(c) 2009-2010 Nanocell, All Rights Reserved
///
/// CONFIDENTIALITY AND RESTRICTED USE
///
/// This software, including any software of third parties embodied herein,
/// contains information and concepts which are confidential to Nanocell
/// and such third parties. This software is licensed for use
/// solely in accordance with the terms and conditions of the applicable
/// license agreement with Nanocell or its authorized distributor.
////////////////////////////////////////////////////////////////////////////////

#include <stdint.h>
#include <string>
#include <cstring>
#include <sstream>
#include <vector>
#include <cstddef>

namespace LteApp
{
    namespace R1
    {
        const uint16_t MIN_BANDS = 1;
        const uint16_t MAX_BANDS = 64;

        const uint16_t MIN_CDMA_BAND_CLASS = 1;
        const uint16_t MAX_CDMA_BAND_CLASS = 32;

        static const uint16_t BYTE_SIZE_OF_TAC = 2;
        static const uint16_t MIN_TAC = 0;
        static const uint16_t MAX_TAC = 0xFFFF;

        static const uint16_t BYTE_SIZE_OF_LAC = 2;

        typedef uint16_t Tac;
        typedef uint16_t Lac;

        //begining RLC CONFIGURATION
        typedef enum RlcConfigurationChoice
        {
            CONFIGURATION_NOT_SPECIFIED = 0,
            AM_CHOSEN = 1,
            UM_BI_DIR_CHOSEN = 2,
            UM_UNI_DIR_UL_CHOSEN = 3,
            UM_UNI_DIR_DL_CHOSEN = 4
        }RlcConfigurationChoice;

        typedef enum TPollRetransmit
        {
            T_POLLRETRANSMIT_MS5 = 0,
            T_POLLRETRANSMIT_MS10 = 1,
            T_POLLRETRANSMIT_MS15 = 2,
            T_POLLRETRANSMIT_MS20 = 3,
            T_POLLRETRANSMIT_MS25 = 4,
            T_POLLRETRANSMIT_MS30 = 5,
            T_POLLRETRANSMIT_MS35 = 6,
            T_POLLRETRANSMIT_MS40 = 7,
            T_POLLRETRANSMIT_MS45 = 8,
            T_POLLRETRANSMIT_MS50 = 9,
            T_POLLRETRANSMIT_MS55 = 10,
            T_POLLRETRANSMIT_MS60 = 11,
            T_POLLRETRANSMIT_MS65 = 12,
            T_POLLRETRANSMIT_MS70 = 13,
            T_POLLRETRANSMIT_MS75 = 14,
            T_POLLRETRANSMIT_MS80 = 15,
            T_POLLRETRANSMIT_MS85 = 16,
            T_POLLRETRANSMIT_MS90 = 17,
            T_POLLRETRANSMIT_MS95 = 18,
            T_POLLRETRANSMIT_MS100 = 19,
            T_POLLRETRANSMIT_MS105 = 20,
            T_POLLRETRANSMIT_MS110 = 21,
            T_POLLRETRANSMIT_MS115 = 22,
            T_POLLRETRANSMIT_MS120 = 23,
            T_POLLRETRANSMIT_MS125 = 24,
            T_POLLRETRANSMIT_MS130 = 25,
            T_POLLRETRANSMIT_MS135 = 26,
            T_POLLRETRANSMIT_MS140 = 27,
            T_POLLRETRANSMIT_MS145 = 28,
            T_POLLRETRANSMIT_MS150 = 29,
            T_POLLRETRANSMIT_MS155 = 30,
            T_POLLRETRANSMIT_MS160 = 31,
            T_POLLRETRANSMIT_MS165 = 32,
            T_POLLRETRANSMIT_MS170 = 33,
            T_POLLRETRANSMIT_MS175 = 34,
            T_POLLRETRANSMIT_MS180 = 35,
            T_POLLRETRANSMIT_MS185 = 36,
            T_POLLRETRANSMIT_MS190 = 37,
            T_POLLRETRANSMIT_MS195 = 38,
            T_POLLRETRANSMIT_MS200 = 39,
            T_POLLRETRANSMIT_MS205 = 40,
            T_POLLRETRANSMIT_MS210 = 41,
            T_POLLRETRANSMIT_MS215 = 42,
            T_POLLRETRANSMIT_MS220 = 43,
            T_POLLRETRANSMIT_MS225 = 44,
            T_POLLRETRANSMIT_MS230 = 45,
            T_POLLRETRANSMIT_MS235 = 46,
            T_POLLRETRANSMIT_MS240 = 47,
            T_POLLRETRANSMIT_MS245 = 48,
            T_POLLRETRANSMIT_MS250 = 49,
            T_POLLRETRANSMIT_MS300 = 50,
            T_POLLRETRANSMIT_MS350 = 51,
            T_POLLRETRANSMIT_MS400 = 52,
            T_POLLRETRANSMIT_MS450 = 53,
            T_POLLRETRANSMIT_MS500 = 54,
            T_POLLRETRANSMIT_SPARE9 = 55,
            T_POLLRETRANSMIT_SPARE8 = 56,
            T_POLLRETRANSMIT_SPARE7 = 57,
            T_POLLRETRANSMIT_SPARE6 = 58,
            T_POLLRETRANSMIT_SPARE5 = 59,
            T_POLLRETRANSMIT_SPARE4 = 60,
            T_POLLRETRANSMIT_SPARE3 = 61,
            T_POLLRETRANSMIT_SPARE2 = 62,
            T_POLLRETRANSMIT_SPARE1 = 63,
            NUM_T_POLLRETRANSMIT,
            MIN_T_POLLRETRANSMIT = T_POLLRETRANSMIT_MS5,
            MAX_T_POLLRETRANSMIT = NUM_T_POLLRETRANSMIT-1,
        }TPollRetransmit;

        typedef enum PollPDU
        {
            P4 = 0,
            P8 = 1,
            P16 = 2,
            P32 = 3,
            P64 = 4,
            P128 = 5,
            P256 = 6,
            P_INF = 7,
            NUM_POLL_PDU,
            MIN_POLL_PDU = P4,
            MAX_POLL_PDU = NUM_POLL_PDU-1
        }PollPDU;

        typedef enum PollByte
        {
            KB25 = 0,
            KB50 = 1,
            KB75 = 2,
            KB100 = 3,
            KB125 = 4,
            KB250 = 5,
            KB375 = 6,
            KB500 = 7,
            KB750 = 8,
            KB1000 = 9,
            KB1250 = 10,
            KB1500 = 11,
            KB2000 = 12,
            KB3000 = 13,
            KB_INF = 14,
            KB_SPARE = 15,
            NUM_POLL_BYTE,
            MIN_POLL_BYTE = KB25,
            MAX_POLL_BYTE = NUM_POLL_BYTE-1
        }PollByte;

        typedef enum MaxRetxThreshold
        {
            T1 = 0,
            T2 = 1,
            T3 = 2,
            T4 = 3,
            T6 = 4,
            T8 = 5,
            T16 = 6,
            T32 = 7,
            NUM_MAX_RETX_THRESHOLD,
            MIN_MAX_RETX_THRESHOLD = T1,
            MAX_MAX_RETX_THRESHOLD = NUM_MAX_RETX_THRESHOLD-1
        }MaxRetxThreshold;

        typedef enum TStatusProhibit
        {
            T_STATUS_PROHIBIT_MS0 = 0,
            T_STATUS_PROHIBIT_MS5 = 1,
            T_STATUS_PROHIBIT_MS10 = 2,
            T_STATUS_PROHIBIT_MS15 = 3,
            T_STATUS_PROHIBIT_MS20 = 4,
            T_STATUS_PROHIBIT_MS25 = 5,
            T_STATUS_PROHIBIT_MS30 = 6,
            T_STATUS_PROHIBIT_MS35 = 7,
            T_STATUS_PROHIBIT_MS40 = 8,
            T_STATUS_PROHIBIT_MS45 = 9,
            T_STATUS_PROHIBIT_MS50 = 10,
            T_STATUS_PROHIBIT_MS55 = 11,
            T_STATUS_PROHIBIT_MS60 = 12,
            T_STATUS_PROHIBIT_MS65 = 13,
            T_STATUS_PROHIBIT_MS70 = 14,
            T_STATUS_PROHIBIT_MS75 = 15,
            T_STATUS_PROHIBIT_MS80 = 16,
            T_STATUS_PROHIBIT_MS85 = 17,
            T_STATUS_PROHIBIT_MS90 = 18,
            T_STATUS_PROHIBIT_MS95 = 19,
            T_STATUS_PROHIBIT_MS100 = 20,
            T_STATUS_PROHIBIT_MS105 = 21,
            T_STATUS_PROHIBIT_MS110 = 22,
            T_STATUS_PROHIBIT_MS115 = 23,
            T_STATUS_PROHIBIT_MS120 = 24,
            T_STATUS_PROHIBIT_MS125 = 25,
            T_STATUS_PROHIBIT_MS130 = 26,
            T_STATUS_PROHIBIT_MS135 = 27,
            T_STATUS_PROHIBIT_MS140 = 28,
            T_STATUS_PROHIBIT_MS145 = 29,
            T_STATUS_PROHIBIT_MS150 = 30,
            T_STATUS_PROHIBIT_MS155 = 31,
            T_STATUS_PROHIBIT_MS160 = 32,
            T_STATUS_PROHIBIT_MS165 = 33,
            T_STATUS_PROHIBIT_MS170 = 34,
            T_STATUS_PROHIBIT_MS175 = 35,
            T_STATUS_PROHIBIT_MS180 = 36,
            T_STATUS_PROHIBIT_MS185 = 37,
            T_STATUS_PROHIBIT_MS190 = 38,
            T_STATUS_PROHIBIT_MS195 = 39,
            T_STATUS_PROHIBIT_MS200 = 40,
            T_STATUS_PROHIBIT_MS205 = 41,
            T_STATUS_PROHIBIT_MS210 = 42,
            T_STATUS_PROHIBIT_MS215 = 43,
            T_STATUS_PROHIBIT_MS220 = 44,
            T_STATUS_PROHIBIT_MS225 = 45,
            T_STATUS_PROHIBIT_MS230 = 46,
            T_STATUS_PROHIBIT_MS235 = 47,
            T_STATUS_PROHIBIT_MS240 = 48,
            T_STATUS_PROHIBIT_MS245 = 49,
            T_STATUS_PROHIBIT_MS250 = 50,
            T_STATUS_PROHIBIT_MS300 = 51,
            T_STATUS_PROHIBIT_MS350 = 52,
            T_STATUS_PROHIBIT_MS400 = 53,
            T_STATUS_PROHIBIT_MS450 = 54,
            T_STATUS_PROHIBIT_MS500 = 55,
            T_STATUS_PROHIBIT_SPARE8 = 56,
            T_STATUS_PROHIBIT_SPARE7 = 57,
            T_STATUS_PROHIBIT_SPARE6 = 58,
            T_STATUS_PROHIBIT_SPARE5 = 59,
            T_STATUS_PROHIBIT_SPARE4 = 60,
            T_STATUS_PROHIBIT_SPARE3 = 61,
            T_STATUS_PROHIBIT_SPARE2 = 62,
            T_STATUS_PROHIBIT_SPARE1 = 63,
            NUM_T_STATUS_PROHIBT,
            MIN_T_STATUS_PROHIBT = T_STATUS_PROHIBIT_MS0,
            MAX_T_STATUS_PROHIBT = NUM_T_STATUS_PROHIBT-1
        }TStatusProhibit;

        typedef enum SnFieldLength
        {
            SIZE_5 = 0,
            SIZE_10 = 1,
            NUM_SN_FIELD_LENGTH
        }SnFieldLength;

        typedef enum TReordering
        {
            T_REORDERING_MS0 = 0,
            T_REORDERING_MS5 = 1,
            T_REORDERING_MS10 = 2,
            T_REORDERING_MS15 = 3,
            T_REORDERING_MS20 = 4,
            T_REORDERING_MS25 = 5,
            T_REORDERING_MS30 = 6,
            T_REORDERING_MS35 = 7,
            T_REORDERING_MS40 = 8,
            T_REORDERING_MS45 = 9,
            T_REORDERING_MS50 = 10,
            T_REORDERING_MS55 = 11,
            T_REORDERING_MS60 = 12,
            T_REORDERING_MS65 = 13,
            T_REORDERING_MS70 = 14,
            T_REORDERING_MS75 = 15,
            T_REORDERING_MS80 = 16,
            T_REORDERING_MS85 = 17,
            T_REORDERING_MS90 = 18,
            T_REORDERING_MS95 = 19,
            T_REORDERING_MS100 = 20,
            T_REORDERING_MS110 = 21,
            T_REORDERING_MS120 = 22,
            T_REORDERING_MS130 = 23,
            T_REORDERING_MS140 = 24,
            T_REORDERING_MS150 = 25,
            T_REORDERING_MS160 = 26,
            T_REORDERING_MS170 = 27,
            T_REORDERING_MS180 = 28,
            T_REORDERING_MS190 = 29,
            T_REORDERING_MS200 = 30,
            T_REORDERING_SPARE = 31,
            NUM_T_REORDERING
        }TReordering;
        //ending RLC CONFIGURATION

        enum MaxHarqTx
        {
            MAX_HARQ_TX_N1 = 0,
            MAX_HARQ_TX_N2 = 1,
            MAX_HARQ_TX_N3 = 2,
            MAX_HARQ_TX_N4 = 3,
            MAX_HARQ_TX_N5 = 4,
            MAX_HARQ_TX_N6 = 5,
            MAX_HARQ_TX_N7 = 6,
            MAX_HARQ_TX_N8 = 7,
            MAX_HARQ_TX_N10 = 8,
            MAX_HARQ_TX_N12 = 9,
            MAX_HARQ_TX_N16 = 10,
            MAX_HARQ_TX_N20 = 11,
            MAX_HARQ_TX_N24 = 12,
            MAX_HARQ_TX_N28 = 13,
            MAX_HARQ_TX_SPARE2 = 14,
            MAX_HARQ_TX_SPARE1 = 15,
            NUM_MAX_HARQ_TX,
            MIN_MAX_HARQ_TX = MAX_HARQ_TX_N1,
            MAX_MAX_HARQ_TX = NUM_MAX_HARQ_TX - 1
        };

        enum PeriodicBsrTimer
        {
            PERIODIC_BSR_TIMER_SF5 = 0,
            PERIODIC_BSR_TIMER_SF10 = 1,
            PERIODIC_BSR_TIMER_SF16 = 2,
            PERIODIC_BSR_TIMER_SF20 = 3,
            PERIODIC_BSR_TIMER_SF32 = 4,
            PERIODIC_BSR_TIMER_SF40 = 5,
            PERIODIC_BSR_TIMER_SF64 = 6,
            PERIODIC_BSR_TIMER_SF80 = 7,
            PERIODIC_BSR_TIMER_SF128 = 8,
            PERIODIC_BSR_TIMER_SF160 = 9,
            PERIODIC_BSR_TIMER_SF320 = 10,
            PERIODIC_BSR_TIMER_SF640 = 11,
            PERIODIC_BSR_TIMER_SF1280 = 12,
            PERIODIC_BSR_TIMER_SF2560 = 13,
            PERIODIC_BSR_TIMER_INF = 14,
            PERIODIC_BSR_TIMER_SPARE1 = 15,
            NUM_PERIODIC_BSR_TIMER,
            MIN_PERIODIC_BSR_TIMER = PERIODIC_BSR_TIMER_SF5,
            MAX_PERIODIC_BSR_TIMER = NUM_PERIODIC_BSR_TIMER-1
        };

        enum RetxBsrTimer
        {
            RETX_BSR_TIMER_SF320,
            RETX_BSR_TIMER_SF640,
            RETX_BSR_TIMER_SF1280,
            RETX_BSR_TIMER_SF2560,
            RETX_BSR_TIMER_SF5120,
            RETX_BSR_TIMER_SF10240,
            RETX_BSR_TIMER_SPARE2,
            RETX_BSR_TIMER_SPARE1,
            NUM_RETX_BSR_TIMER,
            MIN_RETX_BSR_TIMER = RETX_BSR_TIMER_SF320,
            MAX_RETX_BSR_TIMER = NUM_RETX_BSR_TIMER-1
        };

        enum FilterCoefficient
        {
            FC_0 = 0,
            FC_1 = 1,
            FC_2 = 2,
            FC_3 = 3,
            FC_4 = 4,
            FC_5 = 5,
            FC_6 = 6,
            FC_7 = 7,
            FC_8 = 8,
            FC_9 = 9,
            FC_11 = 10,
            FC_13 = 11,
            FC_15 = 12,
            FC_17 = 13,
            FC_19 = 14,
            FC_SPARE1 = 15,
            NUM_FC,
            MIN_FILTER_COEFFICIENT = FC_0,
            MAX_FILTER_COEFFICIENT = NUM_FC-1,
        };

        //////////////////////////////////////////////////////////////////////////
        // Following templates can be placed into a common header file shared by
        // RRC, S1 and X2. Currently, they are here as this common header file
        // still not created yet, and not sure what should be placed into.
        //////////////////////////////////////////////////////////////////////////
        // Template defined for list class,
        // T:       type of list element
        // low:     lower boundary of the list
        // up:      upper boundary of the list
        template<class T, uint16_t low, uint16_t up> class CommonList
        {
        public:
            typedef T innerType_;

            CommonList();
            bool operator== (const CommonList<T, low, up>& rhs) const;
            bool operator!= (const CommonList<T, low, up>& rhs) const;

            void reset();
            bool remove(uint16_t index);

            static const uint16_t MIN_NUM = low;
            static const uint16_t MAX_NUM = up;

            uint16_t numElem_;
            T list_[up];
        };

        template<class T, uint16_t low, uint16_t up>
            const uint16_t CommonList<T, low, up>::MIN_NUM;
        template<class T, uint16_t low, uint16_t up>
            const uint16_t CommonList<T, low, up>::MAX_NUM;

        template<class T, uint16_t low, uint16_t up>
            inline CommonList<T, low, up>::CommonList(): numElem_(0) {}

        template<class T, uint16_t low, uint16_t up>
            inline bool CommonList<T, low, up>::
                        operator== (const CommonList<T, low, up>& rhs) const
        {
            if (this != &rhs)
            {
                if (numElem_ != rhs.numElem_)
                {
                    return false;
                }
                for (uint16_t i = 0; i < numElem_; ++i)
                {
                    if (list_[i] != rhs.list_[i])
                    {
                        return false;
                    }
                }
            }
            return true;
        }

        template<class T, uint16_t low, uint16_t up>
            inline bool CommonList<T, low, up>::
                        operator!= (const CommonList<T, low, up>& rhs) const
        {
            return !operator== (rhs);
        }

        template<class T, uint16_t low, uint16_t up>
            inline void CommonList<T, low, up>::reset()
        {
            numElem_ = 0;
        }

        template<class T, uint16_t low, uint16_t up>
            inline bool CommonList<T, low, up>::
                        remove(uint16_t index)
        {
            if (index < up)
            {
               for(uint16_t iter = index; iter < (numElem_ - 1); iter++)
               {
                  list_[iter] = list_[iter+1];
               }
               numElem_--;

               return true;
            }

            return false;
        }

        class UlSchConfig
        {
        public:
            UlSchConfig();

            bool isMaxHarqTxPresent_;
            MaxHarqTx maxHarqTx_;

        //***** IMPORTANT *****
        // when modifying data members be sure to update the debugDump function
        // as well.

        //////////////////////////////////////////////////////////////////////////////
        ///
        /// @brief Debug information is added to the specified string. The caller can
        ///        output the string to display the information.
        ///
        /// @param[out] outString - string containing the debug info.
        ///
        /// @returns - void
        ///
        //////////////////////////////////////////////////////////////////////////////
            void debugDump(std::string& outString) const;


            bool isPeriodicBsrTimerPresent_;
            PeriodicBsrTimer periodicBsrTimer_;

            RetxBsrTimer retxBsrTimer_;
            bool ttiBundling_;
        };

        inline UlSchConfig::UlSchConfig():
        isMaxHarqTxPresent_(false),
        maxHarqTx_(NUM_MAX_HARQ_TX),
        isPeriodicBsrTimerPresent_ (false),
        periodicBsrTimer_(PERIODIC_BSR_TIMER_SF5),
        retxBsrTimer_(NUM_RETX_BSR_TIMER),
        ttiBundling_(false)
        {
        }

        enum OnDurationTimer
        {
            ON_DURATION_TIMER_PSF1 = 0,
            ON_DURATION_TIMER_PSF2 = 1,
            ON_DURATION_TIMER_PSF3 = 2,
            ON_DURATION_TIMER_PSF4 = 3,
            ON_DURATION_TIMER_PSF5 = 4,
            ON_DURATION_TIMER_PSF6 = 5,
            ON_DURATION_TIMER_PSF8 = 6,
            ON_DURATION_TIMER_PSF10 = 7,
            ON_DURATION_TIMER_PSF20 = 8,
            ON_DURATION_TIMER_PSF30 = 9,
            ON_DURATION_TIMER_PSF40 = 10,
            ON_DURATION_TIMER_PSF50 = 11,
            ON_DURATION_TIMER_PSF60 = 12,
            ON_DURATION_TIMER_PSF80 = 13,
            ON_DURATION_TIMER_PSF100 = 14,
            ON_DURATION_TIMER_PSF200 = 15,
            NUM_ON_DURATION_TIMER,
            MIN_ON_DURATION_TIMER = ON_DURATION_TIMER_PSF1,
            MAX_ON_DURATION_TIMER = NUM_ON_DURATION_TIMER - 1
        };

        enum DrxInactivityTimer
        {
            DRX_INACT_TIMER_PSF1 = 0,
            DRX_INACT_TIMER_PSF2 = 1,
            DRX_INACT_TIMER_PSF3 = 2,
            DRX_INACT_TIMER_PSF4 = 3,
            DRX_INACT_TIMER_PSF5 = 4,
            DRX_INACT_TIMER_PSF6 = 5,
            DRX_INACT_TIMER_PSF8 = 6,
            DRX_INACT_TIMER_PSF10 = 7,
            DRX_INACT_TIMER_PSF20 = 8,
            DRX_INACT_TIMER_PSF30 = 9,
            DRX_INACT_TIMER_PSF40 = 10,
            DRX_INACT_TIMER_PSF50 = 11,
            DRX_INACT_TIMER_PSF60 = 12,
            DRX_INACT_TIMER_PSF80 = 13,
            DRX_INACT_TIMER_PSF100 = 14,
            DRX_INACT_TIMER_PSF200 = 15,
            DRX_INACT_TIMER_PSF300 = 16,
            DRX_INACT_TIMER_PSF500 = 17,
            DRX_INACT_TIMER_PSF750 = 18,
            DRX_INACT_TIMER_PSF1280 = 19,
            DRX_INACT_TIMER_PSF1920 = 20,
            DRX_INACT_TIMER_PSF2560 = 21,
            DRX_INACT_TIMER_SPARE_10 = 22,
            DRX_INACT_TIMER_SPARE_9 = 23,
            DRX_INACT_TIMER_SPARE_8 = 24,
            DRX_INACT_TIMER_SPARE_7 = 25,
            DRX_INACT_TIMER_SPARE_6 = 26,
            DRX_INACT_TIMER_SPARE_5 = 27,
            DRX_INACT_TIMER_SPARE_4 = 28,
            DRX_INACT_TIMER_SPARE_3 = 29,
            DRX_INACT_TIMER_SPARE_2 = 30,
            DRX_INACT_TIMER_SPARE_1 = 31,
            NUM_DRX_INACT_TIMER,
            MIN_DRX_INACT_TIMER = DRX_INACT_TIMER_PSF1,
            MAX_DRX_INACT_TIMER = NUM_DRX_INACT_TIMER -1
        };

        enum DrxRetransmissionTimer
        {
            DRX_RETRANSMISSION_TIMER_PSF1,
            DRX_RETRANSMISSION_TIMER_PSF2,
            DRX_RETRANSMISSION_TIMER_PSF4,
            DRX_RETRANSMISSION_TIMER_PSF6,
            DRX_RETRANSMISSION_TIMER_PSF8,
            DRX_RETRANSMISSION_TIMER_PSF16,
            DRX_RETRANSMISSION_TIMER_PSF24,
            DRX_RETRANSMISSION_TIMER_PSF33,
            NUM_OF_DRX_RETRANSMISSION_TIMER,
            MIN_DRX_RETRANSMISSION_TIMER = DRX_RETRANSMISSION_TIMER_PSF1,
            MAX_DRX_RETRANSMISSION_TIMER = NUM_OF_DRX_RETRANSMISSION_TIMER - 1
        };

        class LongDrxCycleStartOffset
        {
        public:
            enum Choice
            {
                UNSPEC_CHOSEN = 0,
                SF10_CHOSEN = 1,
                SF20_CHOSEN = 2,
                SF32_CHOSEN = 3,
                SF40_CHOSEN = 4,
                SF64_CHOSEN = 5,
                SF80_CHOSEN = 6,
                SF128_CHOSEN = 7,
                SF160_CHOSEN = 8,
                SF256_CHOSEN = 9,
                SF320_CHOSEN = 10,
                SF512_CHOSEN = 11,
                SF640_CHOSEN = 12,
                SF1024_CHOSEN = 13,
                SF1280_CHOSEN = 14,
                SF2048_CHOSEN = 15,
                SF2560_CHOSEN = 16
            };

            LongDrxCycleStartOffset();

            //***** IMPORTANT *****
            // when modifying data members be sure to update the debugDump function
            // as well.

            //////////////////////////////////////////////////////////////////////////////
            ///
            /// @brief Debug information is added to the specified string. The caller can
            ///        output the string to display the information.
            ///
            /// @param[out] outString - string containing the debug info.
            ///
            /// @returns - void
            ///
            //////////////////////////////////////////////////////////////////////////////
            void debugDump(std::string& outString) const;

            static const uint16_t MIN_SF_10 = 0;
            static const uint16_t MAX_SF_10 = 9;
            static const uint16_t MIN_SF_20 = 0;
            static const uint16_t MAX_SF_20 = 19;
            static const uint16_t MIN_SF_32 = 0;
            static const uint16_t MAX_SF_32 = 31;
            static const uint16_t MIN_SF_40 = 0;
            static const uint16_t MAX_SF_40 = 39;
            static const uint16_t MIN_SF_64 = 0;
            static const uint16_t MAX_SF_64 = 63;
            static const uint16_t MIN_SF_80 = 0;
            static const uint16_t MAX_SF_80 = 79;
            static const uint16_t MIN_SF_128 = 0;
            static const uint16_t MAX_SF_128 = 127;
            static const uint16_t MIN_SF_160 = 0;
            static const uint16_t MAX_SF_160 = 159;
            static const uint16_t MIN_SF_256 = 0;
            static const uint16_t MAX_SF_256 = 255;
            static const uint16_t MIN_SF_320 = 0;
            static const uint16_t MAX_SF_320 = 319;
            static const uint16_t MIN_SF_512 = 0;
            static const uint16_t MAX_SF_512 = 511;
            static const uint16_t MIN_SF_640 = 0;
            static const uint16_t MAX_SF_640 = 639;
            static const uint16_t MIN_SF_1024 = 0;
            static const uint16_t MAX_SF_1024 = 1023;
            static const uint16_t MIN_SF_1280 = 0;
            static const uint16_t MAX_SF_1280 = 1279;
            static const uint16_t MIN_SF_2048 = 0;
            static const uint16_t MAX_SF_2048 = 2047;
            static const uint16_t MIN_SF_2560 = 0;
            static const uint16_t MAX_SF_2560 = 2559;

            Choice choice_;

            union
            {
                uint16_t sf10_;
                uint16_t sf20_;
                uint16_t sf32_;
                uint16_t sf40_;
                uint16_t sf64_;
                uint16_t sf80_;
                uint16_t sf128_;
                uint16_t sf160_;
                uint16_t sf256_;
                uint16_t sf320_;
                uint16_t sf512_;
                uint16_t sf640_;
                uint16_t sf1024_;
                uint16_t sf1280_;
                uint16_t sf2048_;
                uint16_t sf2560_;
            } u;
        };

        inline LongDrxCycleStartOffset::LongDrxCycleStartOffset():
        choice_(UNSPEC_CHOSEN)
        {
            memset(&u, 0xff, sizeof(u));
        }

        enum ShortDrxCycle
        {
            SHORT_DRX_CYCLE_SF2,
            SHORT_DRX_CYCLE_SF5,
            SHORT_DRX_CYCLE_SF8,
            SHORT_DRX_CYCLE_SF10,
            SHORT_DRX_CYCLE_SF16,
            SHORT_DRX_CYCLE_SF20,
            SHORT_DRX_CYCLE_SF32,
            SHORT_DRX_CYCLE_SF40,
            SHORT_DRX_CYCLE_SF64,
            SHORT_DRX_CYCLE_SF80,
            SHORT_DRX_CYCLE_SF128,
            SHORT_DRX_CYCLE_SF160,
            SHORT_DRX_CYCLE_SF256,
            SHORT_DRX_CYCLE_SF320,
            SHORT_DRX_CYCLE_SF512,
            SHORT_DRX_CYCLE_SF640,
            NUM_SHORT_DRX_CYCLE,
            MIN_SHORT_DRX_CYCLE = SHORT_DRX_CYCLE_SF2,
            MAX_SHORT_DRX_CYCLE = NUM_SHORT_DRX_CYCLE-1
        };

        class ShortDrx
        {
        public:
            ShortDrx();

            //***** IMPORTANT *****
            // when modifying data members be sure to update the debugDump function
            // as well.

            //////////////////////////////////////////////////////////////////////////////
            ///
            /// @brief Debug information is added to the specified string. The caller can
            ///        output the string to display the information.
            ///
            /// @param[out] outString - string containing the debug info.
            ///
            /// @returns - void
            ///
            //////////////////////////////////////////////////////////////////////////////
            void debugDump(std::string& outString) const;

            ShortDrxCycle shortDrxCycle_;

            static const uint16_t MIN_DRX_SHORT_CYCLE_TIMER = 1;
            static const uint16_t MAX_DRX_SHORT_CYCLE_TIMER = 16;
            uint16_t drxShortCycleTimer_; //INTEGER(1..16)
        };

        inline ShortDrx::ShortDrx():
        shortDrxCycle_(NUM_SHORT_DRX_CYCLE),
        drxShortCycleTimer_(0xffff)
        {
        }

        class DrxConfig
        {
        public:
            DrxConfig();

            //***** IMPORTANT *****
            // when modifying data members be sure to update the debugDump function
            // as well.

            //////////////////////////////////////////////////////////////////////////////
            ///
            /// @brief Debug information is added to the specified string. The caller can
            ///        output the string to display the information.
            ///
            /// @param[out] outString - string containing the debug info.
            ///
            /// @returns - void
            ///
            //////////////////////////////////////////////////////////////////////////////
            void debugDump(std::string& outString) const;

            OnDurationTimer onDurationTimer_;
            DrxInactivityTimer drxInactivityTimer_;
            DrxRetransmissionTimer drxRetransmissionTimer_;
            LongDrxCycleStartOffset longDrxCycleSartOffset_;

            bool isShortDrxPresent_;
            ShortDrx shortDrx_;
        };

        inline DrxConfig::DrxConfig():
        onDurationTimer_(NUM_ON_DURATION_TIMER),
        drxInactivityTimer_(NUM_DRX_INACT_TIMER),
        drxRetransmissionTimer_(NUM_OF_DRX_RETRANSMISSION_TIMER),
        isShortDrxPresent_(false)
        {
        }

        enum TimeAlignmentTimer
        {
            ALIGNMENT_TIMER_SF_500   = 0,
            ALIGNMENT_TIMER_SF_750   = 1,
            ALIGNMENT_TIMER_SF_1280  = 2,
            ALIGNMENT_TIMER_SF_1920  = 3,
            ALIGNMENT_TIMER_SF_2560  = 4,
            ALIGNMENT_TIMER_SF_5120  = 5,
            ALIGNMENT_TIMER_SF_10240 = 6,
            ALIGNMENT_TIMER_INFINITY = 7,
            NUM_OF_ALIGNMENT_TIMER,
            MIN_ALIGNMENT_TIMER = ALIGNMENT_TIMER_SF_500,
            MAX_ALIGNMENT_TIMER = NUM_OF_ALIGNMENT_TIMER - 1
        };

        enum PeriodicPhrTimer
        {
            PERIODIC_PHR_TIMER_SF10 = 0,
            PERIODIC_PHR_TIMER_SF20 = 1,
            PERIODIC_PHR_TIMER_SF50 = 2,
            PERIODIC_PHR_TIMER_SF100 = 3,
            PERIODIC_PHR_TIMER_SF200 = 4,
            PERIODIC_PHR_TIMER_SF500 = 5,
            PERIODIC_PHR_TIMER_SF1000 = 6,
            PERIODIC_PHR_TIMER_INF = 7,
            NUM_PERIODIC_PHR_TIMER,
            MIN_PERIODIC_PHR_TIMER = PERIODIC_PHR_TIMER_SF10,
            MAX_PERIODIC_PHR_TIMER = NUM_PERIODIC_PHR_TIMER-1,
        };

        enum ProhibitPhrTimer
        {
            PROHIBIT_PHR_TIMER_SF0 = 0,
            PROHIBIT_PHR_TIMER_SF10 = 1,
            PROHIBIT_PHR_TIMER_SF20 = 2,
            PROHIBIT_PHR_TIMER_SF50 = 3,
            PROHIBIT_PHR_TIMER_SF100 = 4,
            PROHIBIT_PHR_TIMER_SF200 = 5,
            PROHIBIT_PHR_TIMER_SF500 = 6,
            PROHIBIT_PHR_TIMER_SF1000 = 7,
            NUM_PROHIBIT_PHR_TIMER,
            MIN_PROHIBIT_PHR_TIMER = PROHIBIT_PHR_TIMER_SF0,
            MAX_PROHIBIT_PHR_TIMER = NUM_PROHIBIT_PHR_TIMER-1,
        };

        enum DlPathlossChange
        {
            DL_PATHLOSS_CHANGE_DB1 = 0,
            DL_PATHLOSS_CHANGE_DB3 = 1,
            DL_PATHLOSS_CHANGE_DB6 = 2,
            DL_PATHLOSS_CHANGE_INF = 3,
            NUM_DL_PATHLOSS_CHANGE,
            MIN_DL_PATHLOSS_CHANGE = DL_PATHLOSS_CHANGE_DB1,
            MAX_DL_PATHLOSS_CHANGE = NUM_DL_PATHLOSS_CHANGE -1
        };

        class PhrConfig
        {
        public:
            PhrConfig();

            //***** IMPORTANT *****
            // when modifying data members be sure to update the debugDump function
            // as well.

            //////////////////////////////////////////////////////////////////////////////
            ///
            /// @brief Debug information is added to the specified string. The caller can
            ///        output the string to display the information.
            ///
            /// @param[out] outString - string containing the debug info.
            ///
            /// @returns - void
            ///
            //////////////////////////////////////////////////////////////////////////////
            void debugDump(std::string& outString) const;

            PeriodicPhrTimer periodicPhrTimer_;
            ProhibitPhrTimer prohibitPhrTimer_;
            DlPathlossChange dlPathlossChange_;
        };

        inline PhrConfig::PhrConfig():
        periodicPhrTimer_(NUM_PERIODIC_PHR_TIMER),
        prohibitPhrTimer_(NUM_PROHIBIT_PHR_TIMER),
        dlPathlossChange_(NUM_DL_PATHLOSS_CHANGE)
        {
        }

        typedef uint8_t SrProhibitTimerR9;  // MIN_SR_PROHIBIT_TIMER_R9 ~ MAX_SR_PROHIBIT_TIMER_R9

        const uint8_t MIN_SR_PROHIBIT_TIMER_R9 = 0;
        const uint8_t MAX_SR_PROHIBIT_TIMER_R9 = 7;

        class MacMainConfig
        {
        public:
            MacMainConfig();

            //***** IMPORTANT *****
            // when modifying data members be sure to update the debugDump function
            // as well.

            //////////////////////////////////////////////////////////////////////////////
            ///
            /// @brief Debug information is added to the specified string. The caller can
            ///        output the string to display the information.
            ///
            /// @param[out] outString - string containing the debug info.
            ///
            /// @returns - void
            ///
            //////////////////////////////////////////////////////////////////////////////
            void debugDump(std::string& outString) const;

            enum DrxConfigChoice
            {
                DRX_CONFIG_UNSPEC_CHOSEN = 0,
                DRX_CONFIG_RELEASE_CHOSEN = 1,
                DRX_CONFIG_SETUP_CHOSEN = 2
            };

            enum PhrConfigChoice
            {
                PHR_CONFIG_UNSPEC_CHOSEN = 0,
                PHR_CONFIG_RELEASE_CHOSEN = 1,
                PHR_CONFIG_SETUP_CHOSEN = 2
            };

            bool isUlSchConfigPresent_;
            UlSchConfig ulSchConfig_;

            bool isDrxConfigPresent_;
            DrxConfigChoice drxConfigChoice_;
            // Following field is used when drxConfigChoice_ is DRX_CONFIG_SETUP_CHOSEN
            DrxConfig drxConfig_;

            TimeAlignmentTimer timeAlignmentTimerDedicated_;

            bool isPhrConfigPresent_;
            PhrConfigChoice phrConfigChoice_;
            // Following field is used when phrConfigChoice_ is PHR_CONFIG_SETUP_CHOSEN
            PhrConfig phrConfig_;

            bool isSrProhibitTimerR9Present_;
            SrProhibitTimerR9 srProhibitTimerR9_;
        };

        inline MacMainConfig::MacMainConfig():
        isUlSchConfigPresent_(false),
        isDrxConfigPresent_(false),
        drxConfigChoice_(DRX_CONFIG_UNSPEC_CHOSEN),
        timeAlignmentTimerDedicated_(NUM_OF_ALIGNMENT_TIMER),
        isPhrConfigPresent_(false),
        phrConfigChoice_(PHR_CONFIG_UNSPEC_CHOSEN),
        isSrProhibitTimerR9Present_(false),
        srProhibitTimerR9_(MAX_SR_PROHIBIT_TIMER_R9+1)
        {
        }

        enum SemiPersistSchedIntervalDl
        {
            SEMI_PERSIST_SCHED_INTERVAL_DL_SF10 = 0,
            SEMI_PERSIST_SCHED_INTERVAL_DL_SF20 = 1,
            SEMI_PERSIST_SCHED_INTERVAL_DL_SF32 = 2,
            SEMI_PERSIST_SCHED_INTERVAL_DL_SF40 = 3,
            SEMI_PERSIST_SCHED_INTERVAL_DL_SF64 = 4,
            SEMI_PERSIST_SCHED_INTERVAL_DL_SF80 = 5,
            SEMI_PERSIST_SCHED_INTERVAL_DL_SF128 = 6,
            SEMI_PERSIST_SCHED_INTERVAL_DL_SF160 = 7,
            SEMI_PERSIST_SCHED_INTERVAL_DL_SF320 = 8,
            SEMI_PERSIST_SCHED_INTERVAL_DL_SF640 = 9,
            SEMI_PERSIST_SCHED_INTERVAL_DL_SPARE6 = 10,
            SEMI_PERSIST_SCHED_INTERVAL_DL_SPARE5 = 11,
            SEMI_PERSIST_SCHED_INTERVAL_DL_SPARE4 = 12,
            SEMI_PERSIST_SCHED_INTERVAL_DL_SPARE3 = 13,
            SEMI_PERSIST_SCHED_INTERVAL_DL_SPARE2 = 14,
            SEMI_PERSIST_SCHED_INTERVAL_DL_SPARE1 = 15,
            NUM_SEMI_PERSIST_SCHED_INTERVAL_DL,
            MIN_SEMI_PERSIST_SCHED_INTERVAL_DL = SEMI_PERSIST_SCHED_INTERVAL_DL_SF10,
            MAX_SEMI_PERSIST_SCHED_INTERVAL_DL = NUM_SEMI_PERSIST_SCHED_INTERVAL_DL-1,
        };

        class SpsConfigDl
        {
        public:
           SpsConfigDl();

           static const uint16_t MIN_N1_PUCCH_AN_PERSISENT = 0;
           static const uint16_t MAX_N1_PUCCH_AN_PERSISENT = 2047;

           static const uint8_t MIN_NUM_OF_CONF_SPS_PROCESSES = 1;
           static const uint8_t MAX_NUM_OF_CONF_SPS_PROCESSES = 8;

           static const uint16_t MIN_NUM_OF_N1_PUCCH_AN_PERSISTEN_LIST = 1;
           static const uint16_t MAX_NUM_OF_N1_PUCCH_AN_PERSISTEN_LIST = 4;

           SemiPersistSchedIntervalDl semiPersistSchedIntervalDl_;
           uint8_t numOfConfSpsProcesses_; //INTEGER (1..8)
           CommonList<uint16_t, MIN_NUM_OF_N1_PUCCH_AN_PERSISTEN_LIST,
               MAX_NUM_OF_N1_PUCCH_AN_PERSISTEN_LIST> n1PucchAnPersistentList_;
        };

        inline SpsConfigDl::SpsConfigDl():
        semiPersistSchedIntervalDl_(NUM_SEMI_PERSIST_SCHED_INTERVAL_DL),
        numOfConfSpsProcesses_(0xff)
        {}

        class P0Persistent
        {
        public:
            P0Persistent();

            static const int16_t MIN_P0_NOMINAL_PUSCH_PERSISTENT = -126;
            static const int16_t MAX_P0_NOMINAL_PUSCH_PERSISTENT = 24;

            static const int16_t MIN_P0_UE_PUSCH_PERSISTENT = -8;
            static const int16_t MAX_P0_UE_PUSCH_PERSISTENT = 7;

            int16_t p0NominalPuschPersistent_; //INTEGER(-126..24)
            int16_t p0UePuschPersistent_; //INTEGER(-8..7)
        };

        inline P0Persistent::P0Persistent():
        p0NominalPuschPersistent_(MAX_P0_NOMINAL_PUSCH_PERSISTENT+1),
        p0UePuschPersistent_(MAX_P0_UE_PUSCH_PERSISTENT+1)
        {}

        // Currently, DL is same as UL
        typedef SemiPersistSchedIntervalDl SemiPersistSchedIntervalUl;

        enum RrcTrue
        {
            RRC_TRUE = 0
        };

        enum ImplicitReleaseAfter
        {
            IMPLICIT_RELEASE_AFTER_E2 = 0,
            IMPLICIT_RELEASE_AFTER_E3 = 1,
            IMPLICIT_RELEASE_AFTER_E4 = 2,
            IMPLICIT_RELEASE_AFTER_E8 = 3,
            NUM_IMPLICIT_RELEASE_AFTER,
            MIN_IMPLICIT_RELEASE_AFTER = IMPLICIT_RELEASE_AFTER_E2,
            MAX_IMPLICIT_RELEASE_AFTER = NUM_IMPLICIT_RELEASE_AFTER - 1
        };

        class SpsConfigUl
        {
        public:
            SpsConfigUl();

            SemiPersistSchedIntervalUl semiPersistSchedIntervalUl_;

            ImplicitReleaseAfter implicitReleaseAfter_;

            bool isP0PersistentPresent_;
            P0Persistent p0Persistent_;

            bool isTwoIntervalsConfigPresent_;
            RrcTrue twoIntervalsConfig_;
        };

        inline SpsConfigUl::SpsConfigUl():
        semiPersistSchedIntervalUl_(NUM_SEMI_PERSIST_SCHED_INTERVAL_DL),
        implicitReleaseAfter_(NUM_IMPLICIT_RELEASE_AFTER),
        isP0PersistentPresent_(false),
        isTwoIntervalsConfigPresent_(false),
        twoIntervalsConfig_(RRC_TRUE)
        {}

        class SpsConfig
        {
        public:
            enum DlChoice
            {
                DL_UNSPEC_CHOSEN = 0,
                DL_RELEASE = 1,
                DL_SETUP = 2
            };

            enum UlChoice
            {
                UL_UNSPEC_CHOSEN = 0,
                UL_RELEASE = 1,
                UL_SETUP = 2
            };

            SpsConfig();

            bool isSemiPersistSchedCRntiPresent_;
            uint16_t semiPersistSchedCrnti_;

            bool isSpsConfigDlPresent_;
            DlChoice dlChoice_;
            // Below field is used when dlChoice is DL_SETUP
            SpsConfigDl spsConfigDl_;

            bool isSpsConfigUlPresent_;
            UlChoice ulChoice_;
            // Below field is used when ulChoice is UP_SETUP
            SpsConfigUl spsConfigUl_;
        };

        inline SpsConfig::SpsConfig():
        isSemiPersistSchedCRntiPresent_(false),
        semiPersistSchedCrnti_(0),
        isSpsConfigDlPresent_(false),
        dlChoice_(DL_UNSPEC_CHOSEN),
        isSpsConfigUlPresent_(false),
        ulChoice_(UL_UNSPEC_CHOSEN)
        {}

        enum PA
        {
            PA_DB_6 = 0,
            PA_DB_4_DOT77 = 1,
            PA_DB_3 = 2,
            PA_DB_1_DOT77 = 3,
            PA_DB0 = 4,
            PA_DB1 = 5,
            PA_DB2 = 6,
            PA_DB3 = 7,
            NUM_OF_PA,
            MIN_PA = PA_DB_6,
            MAX_PA = NUM_OF_PA - 1
        };

        class PdschConfigDedicated
        {
        public:
            PdschConfigDedicated();

            //***** IMPORTANT *****
            // when modifying data members be sure to update the debugDump function
            // as well.

            //////////////////////////////////////////////////////////////////////////////
            ///
            /// @brief Debug information is added to the specified string. The caller can
            ///        output the string to display the information.
            ///
            /// @param[out] outString - string containing the debug info.
            ///
            /// @returns - void
            ///
            //////////////////////////////////////////////////////////////////////////////
            void debugDump(std::string& outString) const;

            PA pA_;
        };

        inline PdschConfigDedicated::PdschConfigDedicated():
        pA_(NUM_OF_PA)
        {
        }

        enum TddAckNackFeedbackMode
        {
            TDD_ACK_NACK_FEEDBACK_MODE_BUNDLING = 0,
            TDD_ACK_NACK_FEEDBACK_MODE_MULTIPLEXING = 1,
            NUM_TDD_ACK_NACK_FEEDBACK_MODE,
            MIN_TDD_ACK_NACK_FEEDBACK_MODE = TDD_ACK_NACK_FEEDBACK_MODE_BUNDLING,
            MAX_TDD_ACK_NACK_FEEDBACK_MODE = NUM_TDD_ACK_NACK_FEEDBACK_MODE-1
        };

        enum RepetitionFactor
        {
            REPETITION_FACTOR_N2 = 0,
            REPETITION_FACTOR_N4 = 1,
            REPETITION_FACTOR_N6 = 2,
            REPETITION_FACTOR_SPARE1 =3,
            NUM_REPETITION_FACTOR,
            MIN_REPETITION_FACTOR = REPETITION_FACTOR_N2,
            MAX_REPETITION_FACTOR = NUM_REPETITION_FACTOR - 1
        };

        class AckNackRepetition
        {
        public:
            AckNackRepetition();

            static const uint16_t MIN_N1_PUCCH_AN_REQ = 0;
            static const uint16_t MAX_N1_PUCCH_AN_REQ = 2047;

        //***** IMPORTANT *****
        // when modifying data members be sure to update the debugDump function
        // as well.

        //////////////////////////////////////////////////////////////////////////////
        ///
        /// @brief Debug information is added to the specified string. The caller can
        ///        output the string to display the information.
        ///
        /// @param[out] outString - string containing the debug info.
        ///
        /// @returns - void
        ///
        //////////////////////////////////////////////////////////////////////////////
            void debugDump(std::string& outString) const;

            RepetitionFactor repetitionFactor_;
            uint16_t n1PucchAnReq_; //INTEGER (0..2047)
        };

        inline AckNackRepetition::AckNackRepetition():
        repetitionFactor_(NUM_REPETITION_FACTOR),
        n1PucchAnReq_(MAX_N1_PUCCH_AN_REQ+1)
        {
        }

        class PucchConfigDedicated
        {
        public:
            PucchConfigDedicated();

            //***** IMPORTANT *****
            // when modifying data members be sure to update the debugDump function
            // as well.

            //////////////////////////////////////////////////////////////////////////////
            ///
            /// @brief Debug information is added to the specified string. The caller can
            ///        output the string to display the information.
            ///
            /// @param[out] outString - string containing the debug info.
            ///
            /// @returns - void
            ///
            //////////////////////////////////////////////////////////////////////////////
            void debugDump(std::string& outString) const;

            enum AckNackRepetitionChoice
            {
                UNSPEC_CHOSEN = 0,
                RELEASE = 1,
                SETUP = 2
            };

            AckNackRepetitionChoice ackNackRepetionChoice_;
            //ackNackRepetition_ is used only when ackNackRepetionChoice_ is set to be SETUP
            AckNackRepetition ackNackRepetition_;

            bool isTddAckNackFeedbackModePresent_;
            TddAckNackFeedbackMode tddAckNackFeedbackMode_;
        };

        inline PucchConfigDedicated::PucchConfigDedicated():
        ackNackRepetionChoice_(UNSPEC_CHOSEN),
        isTddAckNackFeedbackModePresent_(false),
        tddAckNackFeedbackMode_(NUM_TDD_ACK_NACK_FEEDBACK_MODE)
        {
        }

        class PuschConfigDedicated
        {
        public:
            PuschConfigDedicated();

            //***** IMPORTANT *****
            // when modifying data members be sure to update the debugDump function
            // as well.

            //////////////////////////////////////////////////////////////////////////////
            ///
            /// @brief Debug information is added to the specified string. The caller can
            ///        output the string to display the information.
            ///
            /// @param[out] outString - string containing the debug info.
            ///
            /// @returns - void
            ///
            //////////////////////////////////////////////////////////////////////////////
            void debugDump(std::string& outString) const;

            static const uint16_t MIN_BETA_OFFSET_ACK_INDEX = 0;
            static const uint16_t MAX_BETA_OFFSET_ACK_INDEX = 15;

            static const uint16_t MIN_BETA_OFFSET_RI_INDEX = 0;
            static const uint16_t MAX_BETA_OFFSET_RI_INDEX = 15;

            static const uint16_t MIN_BETA_OFFSET_CQI_INDEX = 0;
            static const uint16_t MAX_BETA_OFFSET_CQI_INDEX = 15;

            uint16_t betaOffsetAckIndex_;
            uint16_t betaOffsetRiIndex_;
            uint16_t betaOffsetCqiIndex_;
        };

        inline PuschConfigDedicated::PuschConfigDedicated():
        betaOffsetAckIndex_(0xffff),
        betaOffsetRiIndex_(0xffff),
        betaOffsetCqiIndex_(0xffff)
        {
        }

        enum DeltaMcsEnabled
        {
            DELTA_MCS_ENABLED_EN0 = 0,
            DELTA_MCS_ENABLED_EN1 = 1,
            NUM_DELTA_MCS_ENABLED,
            MIN_DELTA_MCS_ENABLED = DELTA_MCS_ENABLED_EN0,
            MAX_DELTA_MCS_ENABLED = NUM_DELTA_MCS_ENABLED -1
        };

        class UplinkPowerControlDedicated
        {
        public:
            UplinkPowerControlDedicated();

            //***** IMPORTANT *****
            // when modifying data members be sure to update the debugDump function
            // as well.

            //////////////////////////////////////////////////////////////////////////////
            ///
            /// @brief Debug information is added to the specified string. The caller can
            ///        output the string to display the information.
            ///
            /// @param[out] outString - string containing the debug info.
            ///
            /// @returns - void
            ///
            //////////////////////////////////////////////////////////////////////////////
            void debugDump(std::string& outString) const;

            static const int16_t MIN_P0_UE_PUSCH = -8;
            static const int16_t MAX_P0_UE_PUSCH = 7;

            static const int16_t MIN_P0_UE_PUCCH = -8;
            static const int16_t MAX_P0_UE_PUCCH = 7;

            static const uint16_t MIN_PSRS_OFFSET = 0;
            static const uint16_t MAX_PSRS_OFFSET = 15;

            static const FilterCoefficient DEFAULT_FILTER_COEFF = FC_4;

            int16_t p0UePusch_; //INTEGER(-8..7)
            DeltaMcsEnabled deltaMcsEnabled_;
            bool accumulationEnabled_;
            int16_t p0UePucch_; //INTEGER(-8..7)
            uint16_t pSrsOffset_; //INTEGER(0..15)
            FilterCoefficient filterCoefficient_;
        };

        inline UplinkPowerControlDedicated::UplinkPowerControlDedicated():
        p0UePusch_(0xffff),
        deltaMcsEnabled_(NUM_DELTA_MCS_ENABLED),
        accumulationEnabled_(false),
        p0UePucch_(0xff),
        pSrsOffset_(0xffff),
        filterCoefficient_(FC_4)
        {
        }

        class TpcIndex
        {
        public:
            enum IndexFormatChoice
            {
                INDEX_FORMAT_NOT_SPECIFIED = 0,
                INDEX_FORMAT_3_CHOSEN = 1,
                INDEX_FORMAT_3A_CHOSEN = 2
            };

            TpcIndex();

            //***** IMPORTANT *****
            // when modifying data members be sure to update the debugDump function
            // as well.

            //////////////////////////////////////////////////////////////////////////////
            ///
            /// @brief Debug information is added to the specified string. The caller can
            ///        output the string to display the information.
            ///
            /// @param[out] outString - string containing the debug info.
            ///
            /// @returns - void
            ///
            //////////////////////////////////////////////////////////////////////////////
            void debugDump(std::string& outString) const;

            static const uint16_t MIN_INDEX_FORMAT_3 = 1;
            static const uint16_t MAX_INDEX_FORMAT_3 = 15;

            static const uint16_t MIN_INDEX_FORMAT_3A = 1;
            static const uint16_t MAX_INDEX_FORMAT_3A = 31;

            IndexFormatChoice choice_;

            union
            {
                uint16_t indexOfFormat3_;
                uint16_t indexOfFormat3A_;
            } u;
        };

        inline TpcIndex::TpcIndex():
        choice_(INDEX_FORMAT_NOT_SPECIFIED)
        {
            memset(&u, 0xff, sizeof(u));
        }

        class TpcPdcchConfig
        {
        public:
            enum PdcchConfigChoice
            {
                PDCCH_CONFIG_NOT_SPECIFIED = 0,
                RELEASE_CHOSEN = 1,
                SETUP_CHOSEN = 2
            };

            TpcPdcchConfig();

            //***** IMPORTANT *****
            // when modifying data members be sure to update the debugDump function
            // as well.

            //////////////////////////////////////////////////////////////////////////////
            ///
            /// @brief Debug information is added to the specified string. The caller can
            ///        output the string to display the information.
            ///
            /// @param[out] outString - string containing the debug info.
            ///
            /// @returns - void
            ///
            //////////////////////////////////////////////////////////////////////////////
            void debugDump(std::string& outString) const;

            static const uint16_t SIZE_BITS_TPC_RNTI = 16;

            PdcchConfigChoice choice_;

            //BIT STRING (SIZE (16))
            uint16_t tpcRnti_;    // selected when SETUP_CHOSEN set
            TpcIndex tpcIndex_;    // selected when SETUP_CHOSEN set
        };

        inline TpcPdcchConfig::TpcPdcchConfig():
        choice_(PDCCH_CONFIG_NOT_SPECIFIED),
        tpcRnti_(0xffff)
        {
        }

        enum CqiRepModeAperiodic
        {
            CQI_REP_MODE_APERIODIC_RM12 = 0,
            CQI_REP_MODE_APERIODIC_RM20 = 1,
            CQI_REP_MODE_APERIODIC_RM22 = 2,
            CQI_REP_MODE_APERIODIC_RM30 = 3,
            CQI_REP_MODE_APERIODIC_RM31 = 4,
            CQI_REP_MODE_APERIODIC_SPARE3 = 5,
            CQI_REP_MODE_APERIODIC_SPARE2 = 6,
            CQI_REP_MODE_APERIODIC_SPARE1 = 7,
            NUM_CQI_REP_MODE_APERIODIC,
            MIN_CQI_REP_MODE_APERIODIC = CQI_REP_MODE_APERIODIC_RM12,
            MAX_CQI_REP_MODE_APERIODIC = NUM_CQI_REP_MODE_APERIODIC-1
        };

        class CqiFormatIndicatorPeriodic
        {
        public:
            enum Choice
            {
                UNSPEC_CHOSEN = 0,
                WIDE_BAND_CQI_CHOSEN = 1,
                SUB_BAND_CQI_CHOSEN = 2
            };

            CqiFormatIndicatorPeriodic();

            //***** IMPORTANT *****
            // when modifying data members be sure to update the debugDump function
            // as well.

            //////////////////////////////////////////////////////////////////////////////
            ///
            /// @brief Debug information is added to the specified string. The caller can
            ///        output the string to display the information.
            ///
            /// @param[out] outString - string containing the debug info.
            ///
            /// @returns - void
            ///
            //////////////////////////////////////////////////////////////////////////////
            void debugDump(std::string& outString) const;

            static const uint16_t MIN_SUB_BAND_CQI = 1;
            static const uint16_t MAX_SUB_BAND_CQI = 4;

            Choice choice_;
            // Following fields used when choice_ is SUB_BAND_CQI_CHOSEN
            uint16_t subBandCqi_;
        };

        inline CqiFormatIndicatorPeriodic::CqiFormatIndicatorPeriodic():
        choice_(UNSPEC_CHOSEN),
        subBandCqi_(0xffff)
        {
        }

        class CqiReportPeriodic
        {
        public:
            CqiReportPeriodic();

            //***** IMPORTANT *****
            // when modifying data members be sure to update the debugDump function
            // as well.

            //////////////////////////////////////////////////////////////////////////////
            ///
            /// @brief Debug information is added to the specified string. The caller can
            ///        output the string to display the information.
            ///
            /// @param[out] outString - string containing the debug info.
            ///
            /// @returns - void
            ///
            //////////////////////////////////////////////////////////////////////////////
            void debugDump(std::string& outString) const;

            static const uint16_t MIN_CQI_PUCCH_RESOURCE_INDEX = 0;
            static const uint16_t MAX_CQI_PUCCH_RESOURCE_INDEX = 1185;

            static const uint16_t MIN_CQI_PMI_CONFIG_INDEX = 0;
            static const uint16_t MAX_CQI_PMI_CONFIG_INDEX = 1023;

            static const uint16_t MIN_RI_CONFIG_INDEX = 0;
            static const uint16_t MAX_RI_CONFIG_INDEX = 1023;

            uint16_t cqiPucchResourceIndex_; //INTEGER(0..1185)
            uint16_t cqiPmiConfigIndex_; //INTEGER(0..1023)
            CqiFormatIndicatorPeriodic cqiFormatIndicatorPeriodic_;
            bool isRiConfigIndexPresent_;
            uint16_t riConfigIndex_; //INTEGER(0..1023)
            bool simultaneousAckNackAndCqi_;
        };

        inline CqiReportPeriodic::CqiReportPeriodic():
        cqiPucchResourceIndex_(MAX_CQI_PUCCH_RESOURCE_INDEX+1),
        cqiPmiConfigIndex_(MAX_CQI_PMI_CONFIG_INDEX+1),
        isRiConfigIndexPresent_(false),
        riConfigIndex_(MAX_RI_CONFIG_INDEX+1),
        simultaneousAckNackAndCqi_(false)
        {
        }

        class CqiReportConfig
        {
        public:
            CqiReportConfig();

            //***** IMPORTANT *****
            // when modifying data members be sure to update the debugDump function
            // as well.

            //////////////////////////////////////////////////////////////////////////////
            ///
            /// @brief Debug information is added to the specified string. The caller can
            ///        output the string to display the information.
            ///
            /// @param[out] outString - string containing the debug info.
            ///
            /// @returns - void
            ///
            //////////////////////////////////////////////////////////////////////////////
            void debugDump(std::string& outString) const;

            enum ReptPeriodicChocie
            {
                UNSPEC_CHOSEN = 0,
                RELEASE_CHOSEN = 1,
                SETUP_CHOSEN = 2
            };

            static const int16_t MIN_NOM_PDSCH_RS_EPRE_OFFSET = -1;
            static const int16_t MAX_NOM_PDSCH_RS_EPRE_OFFSET = 6;

            bool isCqiRepModeAperiodicPresent_;
            CqiRepModeAperiodic cqiRepModeAperiodic_;

            int16_t nomPdschRsEpreOffset_; //INTEGER(-1..6)

            bool isCqiReportPeriodicPresent_;
            ReptPeriodicChocie reptPeriodicChocie_;
            // Fill following field, only reptPeriodicChocie_ is SETUP_CHOSEN
            CqiReportPeriodic cqiReportPeriodic_;
        };

        inline CqiReportConfig::CqiReportConfig():
        isCqiRepModeAperiodicPresent_(false),
        cqiRepModeAperiodic_(NUM_CQI_REP_MODE_APERIODIC),
        nomPdschRsEpreOffset_(0),
        isCqiReportPeriodicPresent_(false),
        reptPeriodicChocie_(UNSPEC_CHOSEN)
        {
        }

        enum SrsBandwidth
        {
            SRS_BW_BW0 = 0,
            SRS_BW_BW1 = 1,
            SRS_BW_BW2 = 2,
            SRS_BW_BW3 = 3,
            NUM_SRS_BW,
            MIN_SRS_BW = SRS_BW_BW0,
            MAX_SRS_BW = NUM_SRS_BW-1
        };

        enum SrsHoppingBandwitdh
        {
            SRS_HOPPING_BW_HBW0 = 0,
            SRS_HOPPING_BW_HBW1 = 1,
            SRS_HOPPING_BW_HBW2 = 2,
            SRS_HOPPING_BW_HBW3 = 3,
            NUM_SRS_HOPPING_BW,
            MIN_SRS_HOPPING_BW = SRS_HOPPING_BW_HBW0,
            MAX_SRS_HOPPING_BW = NUM_SRS_HOPPING_BW-1
        };

        enum CyclicShift
        {
            CYCLIC_SHIFT_CS0 = 0,
            CYCLIC_SHIFT_CS1 = 1,
            CYCLIC_SHIFT_CS2 = 2,
            CYCLIC_SHIFT_CS3 = 3,
            CYCLIC_SHIFT_CS4 = 4,
            CYCLIC_SHIFT_CS5 = 5,
            CYCLIC_SHIFT_CS6 = 6,
            CYCLIC_SHIFT_CS7 = 7,
            NUM_CYCLIC_SHIFT,
            MIN_CYCLIC_SHIFT = CYCLIC_SHIFT_CS0,
            MAX_CYCLIC_SHIFT = NUM_CYCLIC_SHIFT-1
        };

        class SoundingRsUlConfigDedicated
        {
        public:
            SoundingRsUlConfigDedicated();

            //***** IMPORTANT *****
            // when modifying data members be sure to update the debugDump function
            // as well.

            //////////////////////////////////////////////////////////////////////////////
            ///
            /// @brief Debug information is added to the specified string. The caller can
            ///        output the string to display the information.
            ///
            /// @param[out] outString - string containing the debug info.
            ///
            /// @returns - void
            ///
            //////////////////////////////////////////////////////////////////////////////
            void debugDump(std::string& outString) const;

            static const uint16_t MIN_FREQ_DOMAIN_POS = 0;
            static const uint16_t MAX_FREQ_DOMAIN_POS = 23;

            static const uint16_t MIN_SRS_CONFIG_INDEX = 0;
            static const uint16_t MAX_SRS_CONFIG_INDEX = 1023;

            static const uint8_t MIN_TRANSMISSION_COMB = 0;
            static const uint8_t MAX_TRANSMISSION_COMB = 1;

            SrsBandwidth srsBandwidth_;
            SrsHoppingBandwitdh srsHoppingBandwitdh_;
            uint16_t freqDomainPos_; //INTEGER(0..23)
            bool duration_;
            uint16_t srsConfigIndex_; //INTEGER(0..1023)
            uint8_t transmissionComb_; //INTEGER(0..1)
            CyclicShift cyclicShift_;
        };

        inline SoundingRsUlConfigDedicated::SoundingRsUlConfigDedicated():
        srsBandwidth_(NUM_SRS_BW),
        srsHoppingBandwitdh_(NUM_SRS_HOPPING_BW),
        freqDomainPos_(0xffff),
        duration_ (false),
        srsConfigIndex_(0xffff),
        transmissionComb_(0xff),
        cyclicShift_(NUM_CYCLIC_SHIFT)
        {
        }

        class CodebookSubsetRestriction
        {
        public:
            enum AntennaChoice
            {
                ANTENNA_NOT_SPECIFIED = 0,
                N2_TX_ANTENNA_TM3_CHOSEN = 1,
                N4_TX_ANTENNA_TM3_CHOSEN = 2,
                N2_TX_ANTENNA_TM4_CHOSEN = 3,
                N4_TX_ANTENNA_TM4_CHOSEN = 4,
                N2_TX_ANTENNA_TM5_CHOSEN = 5,
                N4_TX_ANTENNA_TM5_CHOSEN = 6,
                N2_TX_ANTENNA_TM6_CHOSEN = 7,
                N4_TX_ANTENNA_TM6_CHOSEN = 8
            };

            CodebookSubsetRestriction();

            //***** IMPORTANT *****
            // when modifying data members be sure to update the debugDump function
            // as well.

            //////////////////////////////////////////////////////////////////////////////
            ///
            /// @brief Debug information is added to the specified string. The caller can
            ///        output the string to display the information.
            ///
            /// @param[out] outString - string containing the debug info.
            ///
            /// @returns - void
            ///
            //////////////////////////////////////////////////////////////////////////////
            void debugDump(std::string& outString) const;

            static const uint8_t MIN_N2_TX_ANTENNA_TM3 = 0;
            static const uint8_t MAX_N2_TX_ANTENNA_TM3 = 0x3;      // 11b

            static const uint8_t MIN_N4_TX_ANTENNA_TM3 = 0;
            static const uint8_t MAX_N4_TX_ANTENNA_TM3 = 0xf;      // 1111b

            static const uint64_t MIN_N4_TX_ANTENNA_TM4 = 0;
            static const uint64_t MAX_N4_TX_ANTENNA_TM4 = 0xffffffffffffffffULL;      // 1111b

            static const uint8_t MIN_N2_TX_ANTENNA_TM4 = 0;
            static const uint8_t MAX_N2_TX_ANTENNA_TM4 = 0x3f;     // 111111b

            static const uint8_t MIN_N2_TX_ANTENNA_TM5 = 0;
            static const uint8_t MAX_N2_TX_ANTENNA_TM5 = 0xf;      // 1111b

            static const uint16_t MIN_N4_TX_ANTENNA_TM5 = 0;
            static const uint16_t MAX_N4_TX_ANTENNA_TM5 = 0xffff;

            static const uint8_t MIN_N2_TX_ANTENNA_TM6 = 0;
            static const uint8_t MAX_N2_TX_ANTENNA_TM6 = 0xf;      // 1111b

            static const uint16_t MIN_N4_TX_ANTENNA_TM6 = 0;
            static const uint16_t MAX_N4_TX_ANTENNA_TM6 = 0xffff;

            static const uint16_t SIZE_N2_TX_ANTENNA_TM3 = 2;
            static const uint16_t SIZE_N4_TX_ANTENNA_TM3 = 4;
            static const uint16_t SIZE_N2_TX_ANTENNA_TM4 = 6;
            static const uint16_t SIZE_N4_TX_ANTENNA_TM4 = 64;
            static const uint16_t SIZE_N2_TX_ANTENNA_TM5 = 4;
            static const uint16_t SIZE_N4_TX_ANTENNA_TM5 = 16;
            static const uint16_t SIZE_N2_TX_ANTENNA_TM6 = 4;
            static const uint16_t SIZE_N4_TX_ANTENNA_TM6 = 16;

            AntennaChoice choice_;

            union
            {
                uint8_t n2TxAntennaTm3_;
                uint8_t n4TxAntennaTm3_;
                uint8_t n2TxAntennaTm4_;
                uint64_t n4TxAntennaTm4_;      // full range
                uint8_t n2TxAntennaTm5_;
                uint16_t n4TxAntennaTm5_;       // full range
                uint8_t n2TxAntennaTm6_;
                uint16_t n4TxAntennaTm6_;       // full range
            } u;
        };

        inline CodebookSubsetRestriction::CodebookSubsetRestriction():
        choice_(ANTENNA_NOT_SPECIFIED)
        {
            memset(&u, 0xff, sizeof(u));
        }

        enum TransmissionMode
        {
            TRANSMISSION_MODE_TM1 = 0,
            TRANSMISSION_MODE_TM2 = 1,
            TRANSMISSION_MODE_TM3 = 2,
            TRANSMISSION_MODE_TM4 = 3,
            TRANSMISSION_MODE_TM5 = 4,
            TRANSMISSION_MODE_TM6 = 5,
            TRANSMISSION_MODE_TM7 = 6,
            TRANSMISSION_MODE_TM8_V920 = 7,
            NUM_TRANSMISSION_MODE,
            MIN_TRANSMISSION_MODE =TRANSMISSION_MODE_TM1,
            MAX_TRANSMISSION_MODE =NUM_TRANSMISSION_MODE -1
        };

        enum UeTransmitAntennaSelectionEnable
        {
            CLOSED_LOOP = 0,
            OPEN_LOOP = 1,
            NUM_UE_TRANSMIT_ANTENNA_SELECT_ENABLE,
            MIN_UE_TRANSMIT_ANTENNA_SELECT_ENABLE = CLOSED_LOOP,
            MAX_UE_TRANSMIT_ANTENNA_SELECT_ENABLE = NUM_UE_TRANSMIT_ANTENNA_SELECT_ENABLE - 1
        };

        class AntennaInfoDedicated
        {
        public:
            AntennaInfoDedicated();

            //***** IMPORTANT *****
            // when modifying data members be sure to update the debugDump function
            // as well.

            //////////////////////////////////////////////////////////////////////////////
            ///
            /// @brief Debug information is added to the specified string. The caller can
            ///        output the string to display the information.
            ///
            /// @param[out] outString - string containing the debug info.
            ///
            /// @returns - void
            ///
            //////////////////////////////////////////////////////////////////////////////
            void debugDump(std::string& outString) const;

            enum UeTransmitAntennaSelectionChoice
            {
                UNSPEC_CHOSEN = 0,
                RELEASE = 1,
                SETUP = 2
            };

            TransmissionMode transmissionMode_;
            bool isCodebookSubsetRestrictionPresent_;
            CodebookSubsetRestriction codebookSubsetRestriction_;

            UeTransmitAntennaSelectionChoice choice_;
            //enable_ is used only when choice_ is set to be ENABLE
            UeTransmitAntennaSelectionEnable enable_;
        };

        inline AntennaInfoDedicated::AntennaInfoDedicated():
        transmissionMode_(NUM_TRANSMISSION_MODE),
        isCodebookSubsetRestrictionPresent_(false),
        choice_(UNSPEC_CHOSEN),
        enable_(NUM_UE_TRANSMIT_ANTENNA_SELECT_ENABLE)
        {}

        class AntennaInfo
        {
        public:
            AntennaInfo();

            //***** IMPORTANT *****
            // when modifying data members be sure to update the debugDump function
            // as well.

            //////////////////////////////////////////////////////////////////////////////
            ///
            /// @brief Debug information is added to the specified string. The caller can
            ///        output the string to display the information.
            ///
            /// @param[out] outString - string containing the debug info.
            ///
            /// @returns - void
            ///
            //////////////////////////////////////////////////////////////////////////////
            void debugDump(std::string& outString) const;

            AntennaInfoDedicated antennaInfoDedicated_;
        };

        inline AntennaInfo::AntennaInfo()
        {
        }

        enum DsrTransMax
        {
            DSR_TRANS_MAX_N4 = 0,
            DSR_TRANS_MAX_N8 = 1,
            DSR_TRANS_MAX_N16 = 2,
            DSR_TRANS_MAX_N32 = 3,
            DSR_TRANS_MAX_N64 = 4,
            DSR_TRANS_MAX_SPARE3 = 5,
            DSR_TRANS_MAX_SPARE2 = 6,
            DSR_TRANS_MAX_SPARE1 = 7,
            NUM_DSR_TRANS_MAX,
            MIN_DSR_TRANS_MAX = DSR_TRANS_MAX_N4,
            MAX_DSR_TRANS_MAX = NUM_DSR_TRANS_MAX-1
        };

        class SchedulingRequestConfig
        {
        public:
            SchedulingRequestConfig();

            //***** IMPORTANT *****
            // when modifying data members be sure to update the debugDump function
            // as well.

            //////////////////////////////////////////////////////////////////////////////
            ///
            /// @brief Debug information is added to the specified string. The caller can
            ///        output the string to display the information.
            ///
            /// @param[out] outString - string containing the debug info.
            ///
            /// @returns - void
            ///
            //////////////////////////////////////////////////////////////////////////////
            void debugDump(std::string& outString) const;

            static const uint16_t MIN_SR_PUCCH_RESOURCE_INDEX = 0;
            static const uint16_t MAX_SR_PUCCH_RESOURCE_INDEX = 2047;

            static const uint16_t MIN_SR_CONFIG_INDEX = 0;
            static const uint16_t MAX_SR_CONFIG_INDEX = 157;

            uint16_t srPucchResourceIndex_; //INTEGER(0..2047)
            uint16_t srConfigIndex_; //INTEGER(0..157)
            DsrTransMax dsrTransMax_;
        };

        inline SchedulingRequestConfig::SchedulingRequestConfig():
        srPucchResourceIndex_(0xffff),
        srConfigIndex_(0xffff),
        dsrTransMax_(NUM_DSR_TRANS_MAX)
        {
        }

        enum CqiMaskR9
        {
            CQI_MASK_R9_SETUP = 0,
            NUM_OF_CQI_MASK_R9,
            MIN_CQI_MASK_R9 = CQI_MASK_R9_SETUP,
            MAX_CQI_MASK_R9 = NUM_OF_CQI_MASK_R9 - 1
        };

        enum PmiRiReportR9
        {
            PMI_RI_REPORT_R9_SETUP = 0,
            NUM_OF_PMI_RI_REPORT_R9,
            MIN_PMI_RI_REPORT_R9 = PMI_RI_REPORT_R9_SETUP,
            MAX_PMI_RI_REPORT_R9 = NUM_OF_PMI_RI_REPORT_R9 - 1
        };

        class CqiReportConfigV920
        {
        public:
            CqiReportConfigV920();

            bool isCqiMaskR9Present_;
            CqiMaskR9 cqiMaskR9_;

            bool isPmiRiReportR9Present_;
            PmiRiReportR9 pmiRiReportR9_;
        };

        inline CqiReportConfigV920::CqiReportConfigV920():
        isCqiMaskR9Present_(false),
        isPmiRiReportR9Present_(false)
        {
        }

        class CodebookSubsetRestrictionV920
        {
        public:
            CodebookSubsetRestrictionV920();

            static const uint8_t BITS_OF_N2_TX_ANTEN_TM8_R9 = 6;
            static const uint8_t BITS_OF_N4_TX_ANTEN_TM8_R9 = 32;

            enum CodebookSubsetRestrChoice
            {
                UNSPECIFIED_CHOSEN = 0,
                N2_TX_ANTENNA_TM8_R9_CHOSEN,
                N4_TX_ANTENNA_TM8_R9_CHOSEN,
                NUM_OF_CODEBOOK_SUBSET_RESTR,
                MIN_CODEBOOK_SUBSET_RESTR = N2_TX_ANTENNA_TM8_R9_CHOSEN,
                MAX_CODEBOOK_SUBSET_RESTR = NUM_OF_CODEBOOK_SUBSET_RESTR - 1
            };
            
            //////////////////////////////////////////////////////////////////////////////
            ///
            /// @brief Debug information is added to the specified string. The caller can
            ///        output the string to display the information.
            ///
            /// @param[out] outString - string containing the debug info.
            ///
            /// @returns - void
            ///
            //////////////////////////////////////////////////////////////////////////////
            void debugDump(std::string& outString) const;
            
            static const uint8_t MIN_N2_TX_ANTEN_TM8_R9 = 0;
            static const uint8_t MAX_N2_TX_ANTEN_TM8_R9 = 0x3f;// 111111b

            static const uint32_t MIN_N4_TX_ANTEN_TM8_R9 = 0;
            static const uint32_t MAX_N4_TX_ANTEN_TM8_R9 = 0xffffffff;// 11111111111111111111111111111111b

            union
            {
                uint8_t n2TxAntennaTm8R9_;  // BIT STRING(6)
                uint32_t n4TxAntennaTm8R9_; // BIT STRING(32)
            } u;

            CodebookSubsetRestrChoice choice_;
        };

        inline CodebookSubsetRestrictionV920::CodebookSubsetRestrictionV920():
        choice_(UNSPECIFIED_CHOSEN)      
        {
            u.n4TxAntennaTm8R9_ = 0;
        }

        class AntennaInfoDedicatedV920
        {
        public:
            AntennaInfoDedicatedV920();

            bool isCodebookSubsetRestrictionV920Present_;
            CodebookSubsetRestrictionV920 codebookSubsetRestrictionV920_;
        };

        inline AntennaInfoDedicatedV920::AntennaInfoDedicatedV920():
        isCodebookSubsetRestrictionV920Present_(false)
        {
        }

        class PhysicalConfigDedicated
        {
        public:
            enum SoundingRsUlConfigDedChoice
            {
                SOUNDING_RS_UL_CONFIG_DED_NOT_SEPCIFIED = 0,
                SOUNDING_RS_UL_CONFIG_DED_RELEASE_CHOSEN = 1,
                SOUNDING_RS_UL_CONFIG_DED_SETUP_CHOSEN = 2
            };

            enum AntennaChoice
            {
                ANTENNA_NOT_SPECIFIED = 0,
                ANTENNA_EXPLICIT_VALUE_CHOSEN = 1,
                ANTENNA_DEFAULT_VALUE_CHOSEN = 2
            };

            enum SchedReqConfigChoice
            {
                SCHED_REQ_CONFIG_NOT_SPECIFIED = 0,
                SCHED_REQ_CONFIG_RELEASE_CHOSEN = 1,
                SCHED_REQ_CONFIG_SETUP_CHOSEN = 2
            };

            PhysicalConfigDedicated();

            //***** IMPORTANT *****
            // when modifying data members be sure to update the debugDump function
            // as well.

            //////////////////////////////////////////////////////////////////////////////
            ///
            /// @brief Debug information is added to the specified string. The caller can
            ///        output the string to display the information.
            ///
            /// @param[out] outString - string containing the debug info.
            ///
            /// @returns - void
            ///
            //////////////////////////////////////////////////////////////////////////////
            void debugDump(std::string& outString) const;

            bool isPdschConfigDedicatedPresent_;
            PdschConfigDedicated pdschConfigDedicated_;

            bool isPucchConfigDedPresent_;
            PucchConfigDedicated pucchConfigDedicated_;

            bool isPuschConfigDedicatedPresent_;
            PuschConfigDedicated puschConfigDedicated_;

            bool isUplinkPowerCtrlDedPresent_;
            UplinkPowerControlDedicated uplinkPowerControlDedicated_;

            bool isTpcPdcchConfigPucchPresent_;
            TpcPdcchConfig tpcPdcchConfigPucch_;

            bool isTpcPdcchConfigPuschPresent_;
            TpcPdcchConfig tpcPdcchConfigPusch_;

            bool isCqiReportConfigPresent_;
            CqiReportConfig cqiReportConfig_;

            bool isSoundingRsUlConfigDedPresent_;
            SoundingRsUlConfigDedChoice soundingRsUlConfigDedChoice_;
            SoundingRsUlConfigDedicated soundingRsUlConfigDedicated_;

            bool isAntennaInfoPresent_;
            AntennaChoice antennaInfoChoice_;
            // Following field antennaInfo_, when isAntennaInfoPresent_ is true,
            // only used if antennaInfoChoice_ above is ANTENNA_EXPLICIT_CHOSEN
            AntennaInfo antennaInfo_;

            bool isSchedulingRequestConfigPresent_;
            SchedReqConfigChoice schedReqConfigChoice_;
            SchedulingRequestConfig schedulingRequestConfig_;
            
            bool isCqiReportConfigV920Present_;
            CqiReportConfigV920 cqiReportConfigV920_;

            bool isAntennaInfoDedicatedV920Present_;
            AntennaInfoDedicatedV920 antennaInfoDedicatedV920_;
        };

        inline PhysicalConfigDedicated::PhysicalConfigDedicated():
        isPdschConfigDedicatedPresent_(false),
        isPucchConfigDedPresent_(false),
        isPuschConfigDedicatedPresent_(false),
        isUplinkPowerCtrlDedPresent_(false),
        isTpcPdcchConfigPucchPresent_(false),
        isTpcPdcchConfigPuschPresent_(false),
        isCqiReportConfigPresent_(false),
        isSoundingRsUlConfigDedPresent_(false),
        soundingRsUlConfigDedChoice_(SOUNDING_RS_UL_CONFIG_DED_NOT_SEPCIFIED),
        isAntennaInfoPresent_(false),
        antennaInfoChoice_(ANTENNA_NOT_SPECIFIED),
        isSchedulingRequestConfigPresent_(false),
        schedReqConfigChoice_(SCHED_REQ_CONFIG_NOT_SPECIFIED),
        isCqiReportConfigV920Present_(false),
        isAntennaInfoDedicatedV920Present_(false)
        {
        }

        class RachConfigDedicated
        {
        public:
           RachConfigDedicated();
           void reset();

           //***** IMPORTANT *****
           // when modifying data members be sure to update the debugDump function
           // as well.

           //////////////////////////////////////////////////////////////////////////////
           ///
           /// @brief Debug information is added to the specified string. The caller can
           ///        output the string to display the information.
           ///
           /// @param[out] outString - string containing the debug info.
           ///
           /// @returns - void
           ///
           //////////////////////////////////////////////////////////////////////////////
            void debugDump(std::string& outString) const;

           static const uint16_t MIN_RA_PREAMBLE_INDEX = 0;
           static const uint16_t MAX_RA_PREAMBLE_INDEX = 63;
           static const uint16_t MIN_RA_PRACH_MASK_INDEX = 0;
           static const uint16_t MAX_RA_PRACH_MASK_INDEX = 15;

           uint16_t raPreambleIndex_;
           uint16_t raPrachMaskIndex_;
        };

        inline RachConfigDedicated::RachConfigDedicated():
        raPreambleIndex_(0xffff),
        raPrachMaskIndex_(0xffff)
        {}

        class VariableContainer
        {
        public:
            VariableContainer();
            ~VariableContainer();

            VariableContainer(const VariableContainer&);
            VariableContainer& operator= (const VariableContainer&);

            void setValue(const uint8_t* value, const uint32_t& length);
            uint32_t getLength() const;
            uint8_t* getValue() const;
            void reset();

        private:
            uint32_t length_;
            uint8_t* value_;
        };

        inline VariableContainer::VariableContainer():
        length_(0),
        value_(NULL)
        {
        }

        inline VariableContainer::~VariableContainer()
        {
            if (NULL != value_)
            {
                delete[] value_;
            }
        }

        inline VariableContainer::VariableContainer(const VariableContainer& rhs):
        length_(rhs.length_),
        value_(NULL)
        {
            if ((0 != length_) && (NULL != rhs.value_))
            {
                value_ = new uint8_t[length_];
                memcpy(value_, rhs.value_, length_);
            }
            else
            {
                length_ = 0;
            }
        }

        inline VariableContainer& VariableContainer::operator=(const VariableContainer& rhs)
        {
            if (this != &rhs)
            {
                setValue(rhs.value_, rhs.length_);
            }

            return *this;
        }

        inline void VariableContainer::setValue(const uint8_t* value, const uint32_t& length)
        {
            if (NULL != value_)
            {
                delete[] value_;
                value_ = NULL;
            }
            length_ = 0;

            if ((0 != length) && (NULL != value))
            {
                value_ = new uint8_t[length];
                memcpy(value_, value, length);
                length_ = length;
            }
        }

        inline uint32_t VariableContainer::getLength() const
        {
            return length_;
        }

        inline uint8_t* VariableContainer::getValue() const
        {
            return value_;
        }

        inline void VariableContainer::reset()
        {
            // Release the memory
            if (value_ != NULL)
            {
                delete[] value_;
                value_ = NULL;
            }
            length_ = 0;
        }

        class GapOffset
        {
        public:
            enum Choice
            {
                UNSPEC_CHOSEN = 0,
                GP0_CHOSEN = 1,
                GP1_CHOSEN = 2
            };

            GapOffset();

            static const uint16_t MIN_GP0 = 0;
            static const uint16_t MAX_GP0 = 39;

            static const uint16_t MIN_GP1 = 0;
            static const uint16_t MAX_GP1 = 79;

            union
            {
                uint16_t gp0_;
                uint16_t gp1_;
            } u;

            Choice choice_;
        };

        inline GapOffset::GapOffset(): choice_(UNSPEC_CHOSEN)
        {
            memset(&u, 0xff, sizeof(u));
        }

        class MeasGapConfig
        {
        public:
           enum GapConfigChoice
           {
              UNSPEC_CHOSEN = 0,
              RELEASE_CHOSEN = 1,
              SETUP_CHOSEN = 2
           };

           MeasGapConfig();

           // Following field are used for SETUP_CHOSEN
           GapConfigChoice gapConfigChoice_;

           GapOffset gapOffset_;
        };

        inline MeasGapConfig::MeasGapConfig():
        gapConfigChoice_(UNSPEC_CHOSEN)
        {}

        enum DefaultPagingCycle
        {
            DEFAULT_PAGINGCYCLE_RF32 = 0,
            DEFAULT_PAGINGCYCLE_RF64 = 1,
            DEFAULT_PAGINGCYCLE_RF128 = 2,
            DEFAULT_PAGINGCYCLE_RF256 = 3,
            NUM_OF_DEFAULT_PAGING_CYCLE,
            MIN_DEFAULT_PAGING_CYCLE = DEFAULT_PAGINGCYCLE_RF32,
            MAX_DEFAULT_PAGING_CYCLE = NUM_OF_DEFAULT_PAGING_CYCLE - 1
        };

        enum Nb
        {
            NB_FOUR_T = 0,
            NB_TWO_T = 1,
            NB_ONE_T = 2,
            NB_HALF_T = 3,
            NB_QUARTER_T = 4,
            NB_ONE_EIGHTH_T = 5,
            NB_ONE_SIXTEENTH_T = 6,
            NB_ONE_THIRTY_SECOND_T = 7,
            NUM_OF_NB,
            MIN_NB = NB_FOUR_T,
            MAX_NB = NUM_OF_NB - 1
        };

        class PcchConfig
        {
        public:
            // copy ctor and assignment operator defined by compiler are good enough
            PcchConfig();

            bool operator== (const PcchConfig& rhs) const;
            bool operator!= (const PcchConfig& rhs) const;

            DefaultPagingCycle defaultPagingCycle_;
            Nb nb_;
        };

        inline PcchConfig::PcchConfig():
        defaultPagingCycle_(NUM_OF_DEFAULT_PAGING_CYCLE),
        nb_(NUM_OF_NB)
        {
        }

        inline bool PcchConfig::operator== (const PcchConfig& rhs) const
        {
            if (this != &rhs)
            {
                if (defaultPagingCycle_ != rhs.defaultPagingCycle_)
                {
                    return false;
                }
                if (nb_ != rhs.nb_)
                {
                    return false;
                }
            }
            return true;
        }

        inline bool PcchConfig::operator!= (const PcchConfig& rhs) const
        {
            return !operator== (rhs);
        }


        enum TraceDepth
        {
            MINIMUM = 0,
            MEDIUM  = 1,
            MAXIMUM = 2,
            MINIMUM_WITHOUT_VENDOR_SPEC_EXT = 3,
            MEDIUM_WITHOUT_VENDOR_SPEC_EXT  = 4,
            MAXIMUM_WITHOUT_VENDOR_SPEC_EXT = 5,
            NUM_OF_TRACE_DEPTH,
            MIN_TRACE_DEPTH = MINIMUM,
            MAX_TRACE_DEPTH = NUM_OF_TRACE_DEPTH - 1
        };

        class EutranTraceId
        {
        public:
            static const uint16_t BYTES_EUTRAN_TRACE_ID = 8;

            EutranTraceId();
            void reset();

            uint64_t getEutranTraceId() const;
            void getEutranTraceId(uint8_t traceId[6], uint8_t traceRecId[2]) const;
            void setEutranTraceId(uint64_t traceId);
            void setEutranTraceId(uint8_t traceId[6], uint8_t traceRecId[2]);

            // OCTET STRING (SIZE (8))
            uint8_t value_[BYTES_EUTRAN_TRACE_ID];
        };

        inline EutranTraceId::EutranTraceId()
        {
            memset(&value_, 0, sizeof(value_));
        }

        typedef uint8_t InterfacesToTrace;

        enum InterfaceToTrace
        {
            INTERFACE_TO_TRACE_NONE = 0,
            INTERFACE_TO_TRACE_S1 = 1 << 0,
            INTERFACE_TO_TRACE_X2 = 1 << 1,
            INTERFACE_TO_TRACE_UU = 1 << 2,
            MAX_INTERFACES_TO_TRACE = (INTERFACE_TO_TRACE_S1 | INTERFACE_TO_TRACE_X2 | INTERFACE_TO_TRACE_UU)
        };

        class TransportLayerAddress
        {
        public:
            TransportLayerAddress();
            TransportLayerAddress& operator=(const TransportLayerAddress& rhs);

            void reset();

            // BIT STRING (SIZE(1..160, ...))
            static const uint16_t MIN_TRANSPORT_ADDRESS_LEN = 1;
            static const uint16_t MAX_TRANSPORT_ADDRESS_LEN = 20;

            uint16_t length_;
            uint8_t value_[MAX_TRANSPORT_ADDRESS_LEN];
        };

        inline TransportLayerAddress::TransportLayerAddress():
        length_(0)
        {
            memset(&value_, 0, sizeof(value_));
        }

        inline TransportLayerAddress& TransportLayerAddress::operator=(const TransportLayerAddress& rhs)
        {
            if (this != &rhs)
            {
                length_ = rhs.length_;
                memcpy(value_, rhs.value_, length_);
            }
            return *this;
        }

        inline void TransportLayerAddress::reset()
        {
            length_ = 0;
            memset(&value_, 0, sizeof(value_));
        }

        class TraceActivation
        {
        public:
            TraceActivation();
            static const uint16_t BITS_INTERFACES_TO_TRACE = 8;

            bool getS1TraceDepth(TraceDepth &traceDepth) const;
            bool getX2TraceDepth(TraceDepth &traceDepth) const;
            bool getUuTraceDepth(TraceDepth &traceDepth) const;
            void setS1TraceDepth(const TraceDepth &traceDepth);
            void setX2TraceDepth(const TraceDepth &traceDepth);
            void setUuTraceDepth(const TraceDepth &traceDepth);

            EutranTraceId eutranTraceId_;

            // BIT STRING (SIZE (8))
            InterfacesToTrace interfacesToTrace_;
            TraceDepth traceDepth_;
            TransportLayerAddress traceCollectionEntityIpAddress_;
        };

        inline TraceActivation::TraceActivation():
        interfacesToTrace_(INTERFACE_TO_TRACE_NONE),
        traceDepth_(NUM_OF_TRACE_DEPTH)
        {
        }

        class EnbId
        {
        public:
            EnbId();

            static const uint16_t BITS_OF_MACRO_ENB_ID = 20;
            static const uint16_t BITS_OF_HOME_ENB_ID = 28;
            static const uint32_t MIN_MACRO_ENB_ID = 0;
            static const uint32_t MAX_MACRO_ENB_ID = 0x000FFFFF;
            static const uint32_t MIN_HOME_ENB_ID = 0;
            static const uint32_t MAX_HOME_ENB_ID = 0x0FFFFFFF;

            enum EnbIdChoice
            {
                MACRO_ENB_ID_CHOSEN = 0,
                HOME_ENB_ID_CHOSEN = 1,
                NUM_OF_ENB_ID_CHOICE,
                MIN_OF_ENB_ID_CHOICE = MACRO_ENB_ID_CHOSEN,
                MAX_OF_ENB_ID_CHOICE = NUM_OF_ENB_ID_CHOICE - 1
            };
            EnbIdChoice choice_;
            uint32_t  macroEnbId_;
            uint32_t  homeEnbId_;
        };

        inline EnbId::EnbId():
        choice_(NUM_OF_ENB_ID_CHOICE),
        macroEnbId_(0xFFFFFFFF),
        homeEnbId_(0xFFFFFFFF)
        {
        }

        //////////////////////////////////////////////////////////////////////
        ///
        /// PlmnIdType FAQ
        /// --------------
        /// 
        /// (1) What is PlmnId?
        ///
        /// PlmnId consists of a 3-digit MCC (Mobile Country Code), followed by
        /// a 2-digit or 3-digit MNC (Mobile Network Code). The digits are decimal.
        /// (The digits may assume values between 0 and 9. As an example, 
        /// if MCC is 123, and MNC is 456, then PlmnId is 123456.
        ///
        /// (2) How are PlmnId digits named in LteApp?
        ///
        /// In LteApp, the digits of PlmnId are individually identified as
        /// demonstrated below:
        /// 
        ///    digit   1     2     3     4     5     6
        ///          mcc1, mcc2, mcc3, mnc1, mnc2, mnc3.
        ///
        /// If MNC is 2-digits, then mnc3 is set to 0xF (filler value).
        /// 
        ///
        /// (3) What is the PlmnIdType memory layout in LteApp
        ///
        /// The layout below is designed to accommodate the parameter encoding
        /// in S1 and RRC interfaces
        ///
        ///              MSB            LSB
        ///             +--------+--------+
        ///     octet1  |  mcc2  |  mcc1  |
        ///             +--------+--------+
        ///     octet2  |  mnc3  |  mcc3  |
        ///             +--------+--------+
        ///     octet3  |  mnc2  |  mnc1  |
        ///             +--------+--------+
        ///
        ///
        ///  (4) What is the PlmnId layout in the standards (24.008 and 25.413)
        ///
        ///  In the standards, the positions of the MNC digits in PlmnId depend
        ///  on whether MNC is a 2-digit or 3-digit number. The positions of the
        ///  PlmnId digits in the standards are graphically shown below
        ///
        ///          (24.008/25.413 Layout for)           (25.413 Layout for)   
        ///           PlmnId with 2-digit MNC           PlmnId with 3-digit MNC  
        ///                                                                         
        ///              MSB            LSB                MSB            LSB    
        ///             +--------+--------+               +--------+--------+    
        ///     octet1  |  mcc2  |  mcc1  |       octet1  |  mcc2  |  mcc1  |    
        ///             +--------+--------+               +--------+--------+    
        ///     octet2  |  0xF   |  mcc3  |       octet2  |  mnc1  |  mcc3  |    
        ///             +--------+--------+               +--------+--------+    
        ///     octet3  |  mnc2  |  mnc1  |       octet3  |  mnc3  |  mnc2  |    
        ///             +--------+--------+               +--------+--------+
        ///
        ///  Note that the digit layout of a 3-digit MNC (as defined in 25.413)
        ///  is different from the LteApp layout,
        ///
        ///  (5) How is the discrepancy between the layouts (LteApp vs 25.413)
        ///  resolved?
        ///
        ///  The 2-digit layout is already in line with the LteApp's PlmnIdType
        ///  layout and does not require any special treatment.
        ///
        ///  If 3-digit MNC is received or to be sent, the S1 and RRC decoders 
        ///  (or encoders) do a translation between LteApp layout and the 
        ///  standard layout. The translation is a cyclic shift as follows
        ///     when decoding: mnc1 -> mnc2 -> mnc3 -> mnc1
        ///     when encoding: mnc1 <- mnc2 <- mnc3 <- mnc1
        ///
        /// 
        ///  (6) As an application programmer, should I be concerned about
        ///  different layouts used?
        ///
        ///  No. Message encoders/decoders take care of the translation. 
        ///  Application programmers should access the individual fields
        ///  of PlmnIdType keeping in mind that *semantically* the digits
        ///  are ordered from most significant to least significant as
        ///  mcc1, mcc2, mcc3, mnc1, mnc2, mnc3.
        ///
        //////////////////////////////////////////////////////////////////////
        class PlmnIdType
        {
        public:
            PlmnIdType();
            void reset();
            void setWithU32(uint32_t plmnU32);
            uint32_t convertPlmnIdToUint32() const;
            std::string getMcc() const;
            std::string getMnc() const;
            std::string getPlmnId() const;

            PlmnIdType& operator= (const PlmnIdType& rhs);
            bool operator== (const PlmnIdType& rhs) const;
            bool operator!= (const PlmnIdType& rhs) const;
            bool operator< (const PlmnIdType& rhs) const;

            static const uint8_t PLMNID_FILTER = 0xF;
            static const uint8_t PLMNID_SIZE = 3;
            static bool convertPlmnIdToHexFormat(std::string& plmnIdString, uint32_t& plmnIdInHex);

#if __BYTE_ORDER == __LITTLE_ENDIAN
            uint8_t mcc1_:4;
            uint8_t mcc2_:4;
            uint8_t mcc3_:4;
            uint8_t mnc3_:4;
            uint8_t mnc1_:4;
            uint8_t mnc2_:4;
#else
            uint8_t mcc2_:4;
            uint8_t mcc1_:4;
            uint8_t mnc3_:4;
            uint8_t mcc3_:4;
            uint8_t mnc2_:4;
            uint8_t mnc1_:4;
#endif
        };

        inline PlmnIdType::PlmnIdType()
        {
            mcc1_ = mcc2_ = mcc3_ = 0;
            mnc1_ = mnc2_ = mnc3_ = 0;
        }
        
        inline PlmnIdType& PlmnIdType::operator= (const PlmnIdType& rhs)
        {
        	  if(this != &rhs)
        	  {
        	  	 mcc1_ = rhs.mcc1_;
        	     mcc2_ = rhs.mcc2_;
        	     mcc3_ = rhs.mcc3_;
        	     mnc1_ = rhs.mnc1_;
        	     mnc2_ = rhs.mnc2_;
        	     mnc3_ = rhs.mnc3_;
        	  }
        	  
        	  return *this;        	  
        }

        inline bool PlmnIdType::operator!= (const PlmnIdType& rhs) const
        {
            return !operator== (rhs);
        }

        inline bool PlmnIdType::operator< (const PlmnIdType& rhs) const
        {
            return (convertPlmnIdToUint32() < rhs.convertPlmnIdToUint32());
        }
        
        inline void PlmnIdType::setWithU32(uint32_t plmnU32)
        {
            // Utility function to convert a uint32_t to PlmnIdType
            // Least significant 6 digits of uint32_t are used in setting PlmnId
            mcc1_ = 0xF & (plmnU32 >> 20);
            mcc2_ = 0xF & (plmnU32 >> 16);
            mcc3_ = 0xF & (plmnU32 >> 12);
            mnc1_ = 0xF & (plmnU32 >>  8);
            mnc2_ = 0xF & (plmnU32 >>  4);
            mnc3_ = 0xF & (plmnU32); 
        }

        inline bool PlmnIdType::operator== (const PlmnIdType& rhs) const
        {
            return ((mcc1_ == rhs.mcc1_) &&
                    (mcc2_ == rhs.mcc2_) &&
                    (mcc3_ == rhs.mcc3_) &&
                    (mnc1_ == rhs.mnc1_) &&
                    (mnc2_ == rhs.mnc2_) &&
                    (mnc3_ == rhs.mnc3_));
        }

        inline uint32_t PlmnIdType::convertPlmnIdToUint32() const
        {
            uint32_t plmnId = 0;
            plmnId |= (static_cast<uint32_t>(mcc1_) << 20);
            plmnId |= (static_cast<uint32_t>(mcc2_) << 16);
            plmnId |= (static_cast<uint32_t>(mcc3_) << 12);
            plmnId |= (static_cast<uint32_t>(mnc1_) <<  8);
            plmnId |= (static_cast<uint32_t>(mnc2_) <<  4);
            plmnId |=  static_cast<uint32_t>(mnc3_);
            return plmnId;     
        }

        inline std::string PlmnIdType::getMcc() const
        {
            std::ostringstream mcc;

            mcc.clear();
            mcc << static_cast<uint16_t>(mcc1_)
                << static_cast<uint16_t>(mcc2_)
                << static_cast<uint16_t>(mcc3_);

            return mcc.str();
        }

        inline std::string PlmnIdType::getMnc() const
        {
            std::ostringstream mnc;

            mnc.clear();
            if (mnc3_ != PLMNID_FILTER)
            {
                mnc << static_cast<uint16_t>(mnc1_)
                    << static_cast<uint16_t>(mnc2_)
                    << static_cast<uint16_t>(mnc3_);
            }
            else
            {
                mnc << static_cast<uint16_t>(mnc1_)
                    << static_cast<uint16_t>(mnc2_);
            }

            return mnc.str();
        }

        inline std::string PlmnIdType::getPlmnId() const
        {
            std::ostringstream plmnId;

            plmnId.clear();
            plmnId << getMcc() << getMnc();

            return plmnId.str();
        }

        class GlobalEnbId
        {
        public:
           GlobalEnbId();

           PlmnIdType plmnIdentity_;
           EnbId enbId_;
        };

        inline GlobalEnbId::GlobalEnbId():
        plmnIdentity_(),
        enbId_()
        {
        }
        
        typedef uint32_t EutranCellIdentity;

        class EutranCgi
        {
        public:
            EutranCgi();
            EutranCgi(const EutranCgi& eutranCgi);
            EutranCgi& operator= (const EutranCgi& eutranCgi);
            bool operator== (const EutranCgi& rhs) const;
            bool operator< (const EutranCgi& rhs) const;
            bool operator!=(const EutranCgi& ecgi);
            friend std::ostream& operator<<(std::ostream &oss, const EutranCgi &ecgi);
            GlobalEnbId getGlobalEnbId();

            static const uint16_t BITS_OF_EUTRAN_CELL_ID = 28;
            static const uint32_t MIN_EUTRAN_CELL_ID = 0x0;
            static const uint32_t MAX_EUTRAN_CELL_ID = 0x0FFFFFFF;

            PlmnIdType plmnId_;
            // BIT STRING (SIZE (28))
            EutranCellIdentity eutranCellId_;
        };

        inline EutranCgi::EutranCgi():
        eutranCellId_(MAX_EUTRAN_CELL_ID+1)
        {
        }

        inline EutranCgi::EutranCgi(const EutranCgi& eutranCgi)
        {
            plmnId_ = eutranCgi.plmnId_;
            eutranCellId_ = eutranCgi.eutranCellId_;
        }

        inline EutranCgi& EutranCgi::operator= (const EutranCgi& eutranCgi)
        {
            if(this != &eutranCgi)
            {
               plmnId_ = eutranCgi.plmnId_;
               eutranCellId_ = eutranCgi.eutranCellId_;
            }

            return *this;
        }

        inline bool EutranCgi::operator== (const EutranCgi& rhs) const
        {
            return ((plmnId_ == rhs.plmnId_) && (eutranCellId_ == rhs.eutranCellId_));
        }

        inline bool EutranCgi::operator< (const EutranCgi& rhs) const
        {
            bool res = false;

            if ((plmnId_ < rhs.plmnId_) ||
                ((plmnId_ == rhs.plmnId_) && (eutranCellId_ < rhs.eutranCellId_)))
            {
                res = true;
            }

            return res;
        }

        inline bool EutranCgi::operator !=(const EutranCgi& eutranCgi)
	{
            return ((plmnId_ != eutranCgi.plmnId_) && (eutranCellId_ != eutranCgi.eutranCellId_));
	}

        enum CellSize
        {
            CELL_SIZE_VERY_SMALL = 0,
            CELL_SIZE_SMALL = 1,
            CELL_SIZE_MEDIUM = 2,
            CELL_SIZE_LARGE = 3,
            NUM_OF_CELL_SIZE,
            MIN_CELL_SIZE = CELL_SIZE_VERY_SMALL,
            MAX_CELL_SIZE = NUM_OF_CELL_SIZE - 1
        };

        class CellType
        {
        public:
            CellType();

            CellSize cellSize_;
        };

        inline CellType::CellType():
        cellSize_(NUM_OF_CELL_SIZE)
        {
        }

        typedef uint16_t TimeUeStayedInCellType;

        static const uint16_t MIN_TIME_UE_STAYED_IN_CELL = 0;
        static const uint16_t MAX_TIME_UE_STAYED_IN_CELL = 4095;

        class LastVisitedEutranCellInfo
        {
        public:
            LastVisitedEutranCellInfo();

            LastVisitedEutranCellInfo& operator= (const LastVisitedEutranCellInfo& lastVisitedEutranCellInfo);

            EutranCgi globalCellId_;
            CellType cellType_;
            TimeUeStayedInCellType timeUeStayedInCell_;
        };

        static const uint16_t MAX_U16 = 0xFFFF;

        inline LastVisitedEutranCellInfo::LastVisitedEutranCellInfo():
        timeUeStayedInCell_(MAX_U16)
        {
        }

        inline LastVisitedEutranCellInfo& LastVisitedEutranCellInfo::operator= (const LastVisitedEutranCellInfo& lastVisitedEutranCellInfo)
        {
            if(this != &lastVisitedEutranCellInfo)
            {
                globalCellId_ = lastVisitedEutranCellInfo.globalCellId_;
                cellType_.cellSize_ = lastVisitedEutranCellInfo.cellType_.cellSize_;
                timeUeStayedInCell_ = lastVisitedEutranCellInfo.timeUeStayedInCell_;
            }

            return *this;
        }

        typedef VariableContainer LastVisitedUtranCellInfo;

        class LastVisitedCellItem
        {
        public:
            LastVisitedCellItem();

            LastVisitedCellItem(const LastVisitedCellItem& lastVisitedCellItem);
            LastVisitedCellItem& operator= (const LastVisitedCellItem& lastVisitedCellItem);

            enum LastVisitedCellItemChoice
            {
                E_UTRAN_CELL_CHOSEN = 0,
                UTRAN_CELL_CHOSEN = 1,
                GERAN_CELL_CHOSEN = 2,
                NUM_OF_LAST_VISITED_CELL_ITEM_CHOICE,
                MIN_LAST_VISITED_CELL_ITEM_CHOICE = E_UTRAN_CELL_CHOSEN,
                MAX_LAST_VISITED_CELL_ITEM_CHOICE = NUM_OF_LAST_VISITED_CELL_ITEM_CHOICE - 1
            };

            LastVisitedCellItemChoice choice_;
            
            LastVisitedEutranCellInfo eutranCell_;
            LastVisitedUtranCellInfo  utranCell_;
        };

        inline LastVisitedCellItem::LastVisitedCellItem():
        choice_(NUM_OF_LAST_VISITED_CELL_ITEM_CHOICE)
        {
        }

        inline LastVisitedCellItem::LastVisitedCellItem(const LastVisitedCellItem& lastVisitedCellItem)
        {
            choice_ = lastVisitedCellItem.choice_;

            switch(choice_)
            {
               case E_UTRAN_CELL_CHOSEN :
               {
                  eutranCell_ = lastVisitedCellItem.eutranCell_;
                  break;
               }
               case UTRAN_CELL_CHOSEN :
               {
                  utranCell_ = lastVisitedCellItem.utranCell_;
                  break;
               }
               default :
               {
                  break;
               }
            }
        }

        inline LastVisitedCellItem& LastVisitedCellItem::operator= (const LastVisitedCellItem& lastVisitedCellItem)
        {
            if (this != &lastVisitedCellItem)
            {
                choice_ = lastVisitedCellItem.choice_;

                switch(choice_)
                {
                   case E_UTRAN_CELL_CHOSEN :
                   {
                      eutranCell_ = lastVisitedCellItem.eutranCell_;
                      break;
                   }
                   case UTRAN_CELL_CHOSEN :
                   {
                      utranCell_ = lastVisitedCellItem.utranCell_;
                      break;
                   }
                   default :
                   {
                      break;
                   }
                }
            }

            return *this;
        }

        class UeHistoryInformation
        {
        public:
            UeHistoryInformation();

            void addLastVisitedCellItem(const LastVisitedCellItem& lastVisitedCellItem);

            static const uint16_t MAX_NUM_OF_LAST_VISITED_CELL = 16;

            std::vector<LastVisitedCellItem> lastVisitedCell_;
        };

        inline UeHistoryInformation::UeHistoryInformation()
        {
        }

        inline void UeHistoryInformation::addLastVisitedCellItem(const LastVisitedCellItem& lastVisitedCellItem)
        {
            if(lastVisitedCell_.size() == MAX_NUM_OF_LAST_VISITED_CELL)
            {
               lastVisitedCell_.erase(lastVisitedCell_.begin());
            }

            lastVisitedCell_.push_back(lastVisitedCellItem);
        }

        //////////////////////////////////////////////////////////////////////////////
        ///
        /// @brief Classes for UeEutraCapability IE
        ///
        //////////////////////////////////////////////////////////////////////////////

        enum BandClassCdma2000
        {
            BC_0 = 0,
            BC_1 = 1,
            BC_2 = 2,
            BC_3 = 3,
            BC_4 = 4,
            BC_5 = 5,
            BC_6 = 6,
            BC_7 = 7,
            BC_8 = 8,
            BC_9 = 9,
            BC_10 = 10,
            BC_11 = 11,
            BC_12 = 12,
            BC_13 = 13,
            BC_14 = 14,
            BC_15 = 15,
            BC_16 = 16,
            BC_17 = 17,
            CDMA2000_BAND_CLASS_SPARE_14 = 18,
            CDMA2000_BAND_CLASS_SPARE_13 = 19,
            CDMA2000_BAND_CLASS_SPARE_12 = 20,
            CDMA2000_BAND_CLASS_SPARE_11 = 21,
            CDMA2000_BAND_CLASS_SPARE_10 = 22,
            CDMA2000_BAND_CLASS_SPARE_9 = 23,
            CDMA2000_BAND_CLASS_SPARE_8 = 24,
            CDMA2000_BAND_CLASS_SPARE_7 = 25,
            CDMA2000_BAND_CLASS_SPARE_6 = 26,
            CDMA2000_BAND_CLASS_SPARE_5 = 27,
            CDMA2000_BAND_CLASS_SPARE_4 = 28,
            CDMA2000_BAND_CLASS_SPARE_3 = 29,
            CDMA2000_BAND_CLASS_SPARE_2 = 30,
            CDMA2000_BAND_CLASS_SPARE_1 = 31,
            NUM_OF_CDMA2000_BAND_CLASS,
            MIN_CDMA2000_BAND_CLASS = BC_0,
            MAX_CDMA2000_BAND_CLASS = NUM_OF_CDMA2000_BAND_CLASS - 1
        };

        class Profile
        {
        public:
            Profile();

            bool profile0x0001_;
            bool profile0x0002_;
            bool profile0x0003_;
            bool profile0x0004_;
            bool profile0x0006_;
            bool profile0x0101_;
            bool profile0x0102_;
            bool profile0x0103_;
            bool profile0x0104_;
        };

        inline Profile::Profile():
        profile0x0001_(false),
        profile0x0002_(false),
        profile0x0003_(false),
        profile0x0004_(false),
        profile0x0006_(false),
        profile0x0101_(false),
        profile0x0102_(false),
        profile0x0103_(false),
        profile0x0104_(false)
        {
        }

        enum MaxNumberRohcContextSessions
        {
            MAX_NUM_ROHC_CONTEXT_SESSIONS_CS2 = 0,
            MAX_NUM_ROHC_CONTEXT_SESSIONS_CS4 = 1,
            MAX_NUM_ROHC_CONTEXT_SESSIONS_CS8 = 2,
            MAX_NUM_ROHC_CONTEXT_SESSIONS_CS12 = 3,
            MAX_NUM_ROHC_CONTEXT_SESSIONS_CS16 = 4,
            MAX_NUM_ROHC_CONTEXT_SESSIONS_CS24 = 5,
            MAX_NUM_ROHC_CONTEXT_SESSIONS_CS32 = 6,
            MAX_NUM_ROHC_CONTEXT_SESSIONS_CS48 = 7,
            MAX_NUM_ROHC_CONTEXT_SESSIONS_CS64 = 8,
            MAX_NUM_ROHC_CONTEXT_SESSIONS_CS128 = 9,
            MAX_NUM_ROHC_CONTEXT_SESSIONS_CS256 = 10,
            MAX_NUM_ROHC_CONTEXT_SESSIONS_CS512 = 11,
            MAX_NUM_ROHC_CONTEXT_SESSIONS_CS1024 = 12,
            MAX_NUM_ROHC_CONTEXT_SESSIONS_CS16384 = 13,
            MAX_NUM_ROHC_CONTEXT_SESSIONS_SPARE2 = 14,
            MAX_NUM_ROHC_CONTEXT_SESSIONS_SPARE1 = 15,
            NUM_MAX_NUM_ROHC_CONTEXT_SESSIONS,
            MIN_MAX_NUM_ROHC_CONTEXT_SESSIONS = MAX_NUM_ROHC_CONTEXT_SESSIONS_CS2,
            MAX_MAX_NUM_ROHC_CONTEXT_SESSIONS = NUM_MAX_NUM_ROHC_CONTEXT_SESSIONS - 1
        };

        class PdcpParameters
        {
        public:
            PdcpParameters();

            static const MaxNumberRohcContextSessions DEFAULT_MAX_NUM_ROHC_CONTEXT_SESSIONS
                = MAX_NUM_ROHC_CONTEXT_SESSIONS_CS16;

            Profile supportedROHCprofiles_;
            MaxNumberRohcContextSessions maxNumberRohcContextSessions_;
        };

        inline PdcpParameters::PdcpParameters():
        maxNumberRohcContextSessions_(DEFAULT_MAX_NUM_ROHC_CONTEXT_SESSIONS)
        {
        }

        class PhyLayerParameters
        {
        public:
            PhyLayerParameters();

            bool ueTxAntennaSelectionSupported_;
            bool ueSpecificRefSigsSupported_;
        };

        inline PhyLayerParameters::PhyLayerParameters():
        ueTxAntennaSelectionSupported_(false),
        ueSpecificRefSigsSupported_(false)
        {
        }

        class SupportedEutraBandListItem
        {
        public:
            SupportedEutraBandListItem();

            static const uint16_t MIN_EUTRA_BAND = 1;
            static const uint16_t MAX_EUTRA_BAND = 64;

            uint16_t eutraBand_;
            bool halfDuplex_;
        };

        inline SupportedEutraBandListItem::SupportedEutraBandListItem():
        eutraBand_(MIN_EUTRA_BAND),
        halfDuplex_(false)
        {
        }

        class RfParameters
        {
        public:
            RfParameters();

            CommonList<SupportedEutraBandListItem, MIN_BANDS, MAX_BANDS> supportedEutraBandList_;
        };

        inline RfParameters::RfParameters()
        {}

        typedef CommonList<SupportedEutraBandListItem, MIN_BANDS, MAX_BANDS>
                SupportedEutraBandList;

        class InterFreqEutraBandListItem
        {
        public:
            InterFreqEutraBandListItem();

            bool interFreqNeedForGaps_;
        };

        inline InterFreqEutraBandListItem::InterFreqEutraBandListItem():
        interFreqNeedForGaps_(false)
        {
        }

        class InterRatBandListItem
        {
        public:
            InterRatBandListItem();

            bool interRatNeedForGaps_;
        };

        inline InterRatBandListItem::InterRatBandListItem():
        interRatNeedForGaps_(false)
        {
        }

        class EutraBandListItem
        {
        public:
            EutraBandListItem();

            CommonList<InterFreqEutraBandListItem, MIN_BANDS, MAX_BANDS> interFreqBandList_;

            bool interRatBandListPresent_;
            CommonList<InterRatBandListItem, MIN_BANDS, MAX_BANDS> interRatBandList_;
        };

        inline EutraBandListItem::EutraBandListItem():
        interRatBandListPresent_(false)
        {
        }

        typedef CommonList<InterFreqEutraBandListItem, MIN_BANDS, MAX_BANDS>
                InterFreqEutraBandList;

        typedef CommonList<InterRatBandListItem, MIN_BANDS, MAX_BANDS>
                InterRatBandList;

        typedef std::vector<EutraBandListItem> EutraBandList;

        class MeasParameters
        {
        public:
            MeasParameters();

            EutraBandList eutraBandList_;
        };

        inline MeasParameters::MeasParameters()
        {
        }

        enum UtraFddBand
        {
            UTRA_FDD_BAND_I = 0,
            UTRA_FDD_BAND_II = 1,
            UTRA_FDD_BAND_III = 2,
            UTRA_FDD_BAND_IV = 3,
            UTRA_FDD_BAND_V = 4,
            UTRA_FDD_BAND_VI = 5,
            UTRA_FDD_BAND_VII = 6,
            UTRA_FDD_BAND_VIII = 7,
            UTRA_FDD_BAND_IX = 8,
            UTRA_FDD_BAND_X = 9,
            UTRA_FDD_BAND_XI = 10,
            UTRA_FDD_BAND_XII = 11,
            UTRA_FDD_BAND_XIII = 12,
            UTRA_FDD_BAND_XIV = 13,
            UTRA_FDD_BAND_XV = 14,
            UTRA_FDD_BAND_XVI = 15,
            UTRA_FDD_BAND_XVII = 16,
            UTRA_FDD_BAND_XVIII = 17,
            UTRA_FDD_BAND_XIX = 18,
            UTRA_FDD_BAND_XX = 19,
            UTRA_FDD_BAND_XXI = 20,
            UTRA_FDD_BAND_XXII = 21,
            UTRA_FDD_BAND_XXIII = 22,
            UTRA_FDD_BAND_XXIV = 23,
            UTRA_FDD_BAND_XXV = 24,
            UTRA_FDD_BAND_XXVI = 25,
            UTRA_FDD_BAND_XXVII = 26,
            UTRA_FDD_BAND_XXVIII = 27,
            UTRA_FDD_BAND_XXIX = 28,
            UTRA_FDD_BAND_XXX = 29,
            UTRA_FDD_BAND_XXXI = 30,
            UTRA_FDD_BAND_XXXII = 31,
            NUM_UTRA_FDD_BAND,
            MIN_UTRA_FDD_BAND = UTRA_FDD_BAND_I,
            MAX_UTRA_FDD_BAND = NUM_UTRA_FDD_BAND-1
        };

        class InterRatUtraFddParameters
        {
        public:
            InterRatUtraFddParameters();

            CommonList<UtraFddBand, MIN_BANDS, MAX_BANDS> supportedUtraFddBandList_;
        };

        inline InterRatUtraFddParameters::InterRatUtraFddParameters()
        {
        }

        typedef CommonList<UtraFddBand, MIN_BANDS, MAX_BANDS>
                SupportedUtraFddBandList;

        enum UtraTddBand
        {
            UTRA_TDD_BAND_A = 0,
            UTRA_TDD_BAND_B = 1,
            UTRA_TDD_BAND_C = 2,
            UTRA_TDD_BAND_D = 3,
            UTRA_TDD_BAND_E = 4,
            UTRA_TDD_BAND_F = 5,
            UTRA_TDD_BAND_G = 6,
            UTRA_TDD_BAND_H = 7,
            UTRA_TDD_BAND_I = 8,
            UTRA_TDD_BAND_J = 9,
            UTRA_TDD_BAND_K = 10,
            UTRA_TDD_BAND_L = 11,
            UTRA_TDD_BAND_M = 12,
            UTRA_TDD_BAND_N = 13,
            UTRA_TDD_BAND_O = 14,
            UTRA_TDD_BAND_P = 15,
            NUM_UTRA_TDD_BAND,
            MIN_UTRA_TDD_BAND = UTRA_TDD_BAND_A,
            MAX_UTRA_TDD_BAND = NUM_UTRA_TDD_BAND-1
        };

        class InterRatUtraTdd128Parameters
        {
        public:
            InterRatUtraTdd128Parameters();

            CommonList<UtraTddBand, MIN_BANDS, MAX_BANDS> supportedUtraTdd128BandList_;
        };

        inline InterRatUtraTdd128Parameters::InterRatUtraTdd128Parameters()
        {
        }

        typedef CommonList<UtraTddBand, MIN_BANDS, MAX_BANDS>
                SupportedUtraTdd128BandList;

        class InterRatUtraTdd384Parameters
        {
        public:
            InterRatUtraTdd384Parameters();

            CommonList<UtraTddBand, MIN_BANDS, MAX_BANDS> supportedUtraTdd384BandList_;
        };

        inline InterRatUtraTdd384Parameters::InterRatUtraTdd384Parameters()
        {
        }

        typedef CommonList<UtraTddBand, MIN_BANDS, MAX_BANDS>
                SupportedUtraTdd384BandList;

        class InterRatUtraTdd768Parameters
        {
        public:
            InterRatUtraTdd768Parameters();

            CommonList<UtraTddBand, MIN_BANDS, MAX_BANDS> supportedUtraTdd768BandList_;
        };

        inline InterRatUtraTdd768Parameters::InterRatUtraTdd768Parameters()
        {
        }

        typedef CommonList<UtraTddBand, MIN_BANDS, MAX_BANDS>
                SupportedUtraTdd768BandList;

        enum GeranBand
        {
            GERAN_BAND_GSM450 = 0,
            GERAN_BAND_GSM480 = 1,
            GERAN_BAND_GSM710 = 2,
            GERAN_BAND_GSM750 = 3,
            GERAN_BAND_GSM810 = 4,
            GERAN_BAND_GSM850 = 5,
            GERAN_BAND_GSM900P = 6,
            GERAN_BAND_GSM900E = 7,
            GERAN_BAND_GSM900R = 8,
            GERAN_BAND_GSM1800 = 9,
            GERAN_BAND_GSM1900 = 10,
            GERAN_BAND_SPARE5 = 11,
            GERAN_BAND_SPARE4 = 12,
            GERAN_BAND_SPARE3 = 13,
            GERAN_BAND_SPARE2 = 14,
            GERAN_BAND_SPARE1 = 15,
            NUM_GERAN_BAND,
            MIN_GERAN_BAND = GERAN_BAND_GSM450,
            MAX_GERAN_BAND = NUM_GERAN_BAND-1
        };

        class InterRatGeranParameters
        {
        public:
            InterRatGeranParameters();

            CommonList<GeranBand, MIN_BANDS, MAX_BANDS> supportedGeranBandList_;

            bool interRatPsHoToGeran_;
        };

        inline InterRatGeranParameters::InterRatGeranParameters():
        interRatPsHoToGeran_(false)
        {
        }

        typedef CommonList<GeranBand, MIN_BANDS, MAX_BANDS>
                SupportedGeranBandList;

        enum Cdma2000Config
        {
            CDMA2000_CONFIG_SINGLE = 0,
            CDMA2000_CONFIG_DUAL = 1,
            NUM_CDMA2000_CONFIG,
            MIN_CDMA2000_CONFIG = CDMA2000_CONFIG_SINGLE,
            MAX_CDMA2000_CONFIG = NUM_CDMA2000_CONFIG-1
        };

        typedef CommonList<BandClassCdma2000, MIN_CDMA_BAND_CLASS, MAX_CDMA_BAND_CLASS>
                SupportedCdma2000BandList;

        class InterRatCdma2000HrpdParameters
        {
        public:
            InterRatCdma2000HrpdParameters();

            SupportedCdma2000BandList supportedHrpdBandList_;

            Cdma2000Config cdma2000HrpdTxConfig_;
            Cdma2000Config cdma2000HrpdRxConfig_;
        };

        inline InterRatCdma2000HrpdParameters::InterRatCdma2000HrpdParameters():
        cdma2000HrpdTxConfig_(CDMA2000_CONFIG_SINGLE),
        cdma2000HrpdRxConfig_(CDMA2000_CONFIG_SINGLE)
        {
        }

        class InterRatCdma20001xrttParameters
        {
        public:
            InterRatCdma20001xrttParameters();

            SupportedCdma2000BandList supported1xRttBandList_;

            Cdma2000Config cdma20001xRttTxConfig_;
            Cdma2000Config cdma20001xRttRxConfig_;
        };

        inline InterRatCdma20001xrttParameters::InterRatCdma20001xrttParameters():
        cdma20001xRttTxConfig_(CDMA2000_CONFIG_SINGLE),
        cdma20001xRttRxConfig_(CDMA2000_CONFIG_SINGLE)
        {
        }

        class InterRatParameters
        {
        public:
            InterRatParameters();

            bool isInterRatUtraFddParametersPresent_;
            InterRatUtraFddParameters interRatUtraFddParameters_;

            bool isInterRatUtraTdd128ParametersPresent_;
            InterRatUtraTdd128Parameters interRatUtraTdd128Parameters_;

            bool isInterRatUtraTdd384ParametersPresent_;
            InterRatUtraTdd384Parameters interRatUtraTdd384Parameters_;

            bool isInterRatUtraTdd768ParametersPresent_;
            InterRatUtraTdd768Parameters interRatUtraTdd768Parameters_;

            bool isInterRatGeranParametersPresent_;
            InterRatGeranParameters interRatGeranParameters_;

            bool isInterRatCdma2000HrpdParametersPresent_;
            InterRatCdma2000HrpdParameters interRatCdma2000HrpdParameters_;

            bool isInterRatCdma20001xrttParametersPresent_;
            InterRatCdma20001xrttParameters interRatCdma20001xrttParameters_;
        };

        inline InterRatParameters::InterRatParameters():
        isInterRatUtraFddParametersPresent_(false),
        isInterRatUtraTdd128ParametersPresent_(false),
        isInterRatUtraTdd384ParametersPresent_(false),
        isInterRatUtraTdd768ParametersPresent_(false),
        isInterRatGeranParametersPresent_(false),
        isInterRatCdma2000HrpdParametersPresent_(false),
        isInterRatCdma20001xrttParametersPresent_(false)
        {
        }

        enum AccessStratumRelease
        {
            ACCESS_STRATUM_RELEASE_RELEASE8 = 0,
            ACCESS_STRATUM_RELEASE_RELEASE9 = 1,
            ACCESS_STRATUM_RELEASE_SPACE6 = 2,
            ACCESS_STRATUM_RELEASE_SPACE5 = 3,
            ACCESS_STRATUM_RELEASE_SPACE4 = 4,
            ACCESS_STRATUM_RELEASE_SPACE3 = 5,
            ACCESS_STRATUM_RELEASE_SPACE2 = 6,
            ACCESS_STRATUM_RELEASE_SPACE1 = 7,
            NUM_ACCESS_STRATUM_RELEASE,
            MIN_ACCESS_STRATUM_RELEASE = ACCESS_STRATUM_RELEASE_RELEASE8,
            MAX_ACCESS_STRATUM_RELEASE = NUM_ACCESS_STRATUM_RELEASE-1
        };


        enum UeFeature
        {
            UE_FEATURE_BIT01,
            UE_FEATURE_BIT02,
            UE_FEATURE_BIT03,
            UE_FEATURE_BIT04,
            UE_FEATURE_BIT05,
            UE_FEATURE_BIT06,
            UE_FEATURE_BIT07,
            UE_FEATURE_BIT08,
            UE_FEATURE_BIT09,
            UE_FEATURE_BIT10,
            UE_FEATURE_BIT11,
            UE_FEATURE_BIT12,
            UE_FEATURE_BIT13,
            UE_FEATURE_BIT14,
            UE_FEATURE_BIT15,
            UE_FEATURE_BIT16,
            UE_FEATURE_BIT17,
            UE_FEATURE_BIT18,
            UE_FEATURE_BIT19,
            UE_FEATURE_BIT20,
            UE_FEATURE_BIT21,
            UE_FEATURE_BIT22,
            UE_FEATURE_BIT23,
            UE_FEATURE_BIT24,
            UE_FEATURE_BIT25,
            UE_FEATURE_BIT26,
            UE_FEATURE_BIT27,
            UE_FEATURE_BIT28,
            UE_FEATURE_BIT29,
            UE_FEATURE_BIT30,
            UE_FEATURE_BIT31,
            UE_FEATURE_BIT32,
            NUM_UE_FEATURE,
            HRPD_B2_MR_IN_CONNECTED = UE_FEATURE_BIT26,
            ANR_RELATED_INTRA_FREQ_MEAS_REPORTING = UE_FEATURE_BIT17,
            MIN_UE_FEATURE = UE_FEATURE_BIT01,
            MAX_UE_FEATURE = NUM_UE_FEATURE -1
        };

        enum EnhancedDualLayerFddR9
        {
            ENHANCED_DUAL_LAYER_FDD_R9_SUPPORTED = 0,
            NUM_OF_ENHANCED_DUAL_LAYER_FDD_R9,
            MIN_ENHANCED_DUAL_LAYER_FDD_R9 = ENHANCED_DUAL_LAYER_FDD_R9_SUPPORTED,
            MAX_ENHANCED_DUAL_LAYER_FDD_R9 = NUM_OF_ENHANCED_DUAL_LAYER_FDD_R9 - 1
        };

        enum EnhancedDualLayerTddR9
        {
            ENHANCED_DUAL_LAYER_TDD_R9_SUPPORTED = 0,
            NUM_OF_ENHANCED_DUAL_LAYER_TDD_R9,
            MIN_ENHANCED_DUAL_LAYER_TDD_R9 = ENHANCED_DUAL_LAYER_TDD_R9_SUPPORTED,
            MAX_ENHANCED_DUAL_LAYER_TDD_R9 = NUM_OF_ENHANCED_DUAL_LAYER_TDD_R9 - 1
        };

        class PhyLayerParametersV920
        {
        public:
            PhyLayerParametersV920();

            bool isEnhancedDualLayerFddR9Present_;
            EnhancedDualLayerFddR9 enhancedDualLayerFddR9_;

            bool isEnhancedDualLayerTddR9Present_;
            EnhancedDualLayerTddR9 enhancedDualLayerTddR9_;
        };

        inline PhyLayerParametersV920::PhyLayerParametersV920():
        isEnhancedDualLayerFddR9Present_(false),
        enhancedDualLayerFddR9_(NUM_OF_ENHANCED_DUAL_LAYER_FDD_R9),
        isEnhancedDualLayerTddR9Present_(false),
        enhancedDualLayerTddR9_(NUM_OF_ENHANCED_DUAL_LAYER_TDD_R9)
        {            
        }

        enum DtmR9
        {
            DTM_R9_SUPPORTED = 0,
            NUM_OF_DTM_R9,
            MIN_DTM_R9 = DTM_R9_SUPPORTED,
            MAX_DTM_R9 = NUM_OF_DTM_R9 - 1
        };

        enum ERedirectionGeranR9
        {
            E_REDIRECTION_GERAN_R9_SUPPORTED = 0,
            NUM_OF_E_REDIRECTION_GERAN_R9,
            MIN_E_REDIRECTION_GERAN_R9 = E_REDIRECTION_GERAN_R9_SUPPORTED,
            MAX_E_REDIRECTION_GERAN_R9 = NUM_OF_E_REDIRECTION_GERAN_R9 - 1
        };

        class IratParametersGeranV920
        {
        public:
            IratParametersGeranV920();

            bool isDtmR9Present_;
            DtmR9 dtmR9_;

            bool isERedirectionGeranR9Present_;
            ERedirectionGeranR9 eRedirectionGeranR9_;
        };

        inline IratParametersGeranV920::IratParametersGeranV920():
        isDtmR9Present_(false),
        dtmR9_(NUM_OF_DTM_R9),
        isERedirectionGeranR9Present_(false),
        eRedirectionGeranR9_(NUM_OF_E_REDIRECTION_GERAN_R9)
        {
        }

        enum SonParaRachReportR9
        {
            SON_PARA_RACH_REPORT_R9_SUPPORTED = 0,
            NUM_OF_SON_PARA_RACH_REPORT_R9,
            MIN_SON_PARA_RACH_REPORT_R9 = SON_PARA_RACH_REPORT_R9_SUPPORTED,
            MAX_SON_PARA_RACH_REPORT_R9 = NUM_OF_SON_PARA_RACH_REPORT_R9 - 1
        };

        enum IntraFreqProximityIndR9
        {
            INTRA_FREQ_PROXIMITY_IND_R9_SUPPORTED = 0,
            NUM_OF_INTRA_FREQ_PROXIMITY_IND_R9,
            MIN_INTRA_FREQ_PROXIMITY_IND_R9 = INTRA_FREQ_PROXIMITY_IND_R9_SUPPORTED,
            MAX_INTRA_FREQ_PROXIMITY_IND_R9 = NUM_OF_INTRA_FREQ_PROXIMITY_IND_R9 - 1
        };

        enum InterFreqProximityIndR9
        {
            INTER_FREQ_PROXIMITY_IND_R9_SUPPORTED = 0,
            NUM_OF_INTER_FREQ_PROXIMITY_IND_R9,
            MIN_INTER_FREQ_PROXIMITY_IND_R9 = INTER_FREQ_PROXIMITY_IND_R9_SUPPORTED,
            MAX_INTER_FREQ_PROXIMITY_IND_R9 = NUM_OF_INTER_FREQ_PROXIMITY_IND_R9 - 1
        };

        enum UtranProximityIndR9
        {
            UTRAN_PROXIMITY_IND_R9_SUPPORTED = 0,
            NUM_OF_UTRAN_PROXIMITY_IND_R9,
            MIN_UTRAN_PROXIMITY_IND_R9 = UTRAN_PROXIMITY_IND_R9_SUPPORTED,
            MAX_UTRAN_PROXIMITY_IND_R9 = NUM_OF_UTRAN_PROXIMITY_IND_R9 - 1
        };

        class CsgProximityIndParaR9
        {
        public:
            CsgProximityIndParaR9();

            bool isIntraFreqProximityIndR9Present_;
            IntraFreqProximityIndR9 intraFreqProximityIndR9_;

            bool isInterFreqProximityIndR9Present_;
            InterFreqProximityIndR9 interFreqProximityIndR9_;

            bool isUtranProximityIndR9Present_;
            UtranProximityIndR9 utranProximityIndR9_;
        };

        inline CsgProximityIndParaR9::CsgProximityIndParaR9():
        isIntraFreqProximityIndR9Present_(false),
        intraFreqProximityIndR9_(NUM_OF_INTRA_FREQ_PROXIMITY_IND_R9),
        isInterFreqProximityIndR9Present_(false),
        interFreqProximityIndR9_(NUM_OF_INTER_FREQ_PROXIMITY_IND_R9),
        isUtranProximityIndR9Present_(false),
        utranProximityIndR9_(NUM_OF_UTRAN_PROXIMITY_IND_R9)
        {            
        }

        enum IntraFreqSiAcqForHoR9
        {
            INTRA_FREQ_SI_ACQ_FOR_HO_R9_SUPPORTED = 0,
            NUM_OF_INTRA_FREQ_SI_ACQ_FOR_HO_R9,
            MIN_INTRA_FREQ_SI_ACQ_FOR_HO_R9 = INTRA_FREQ_SI_ACQ_FOR_HO_R9_SUPPORTED,
            MAX_INTRA_FREQ_SI_ACQ_FOR_HO_R9 = NUM_OF_INTRA_FREQ_SI_ACQ_FOR_HO_R9 - 1
        };

        enum InterFreqSiAcqForHoR9
        {
            INTER_FREQ_SI_ACQ_FOR_HO_R9_SUPPORTED = 0,
            NUM_OF_INTER_FREQ_SI_ACQ_FOR_HO_R9,
            MIN_INTER_FREQ_SI_ACQ_FOR_HO_R9 = INTER_FREQ_SI_ACQ_FOR_HO_R9_SUPPORTED,
            MAX_INTER_FREQ_SI_ACQ_FOR_HO_R9 = NUM_OF_INTER_FREQ_SI_ACQ_FOR_HO_R9 - 1
        };

        enum UtranSiAcqForHoR9
        {
            UTRAN_SI_ACQ_FOR_HO_R9_SUPPORTED = 0,
            NUM_OF_UTRAN_SI_ACQ_FOR_HO_R9,
            MIN_UTRAN_SI_ACQ_FOR_HO_R9 = UTRAN_SI_ACQ_FOR_HO_R9_SUPPORTED,
            MAX_UTRAN_SI_ACQ_FOR_HO_R9 = NUM_OF_UTRAN_SI_ACQ_FOR_HO_R9 - 1
        };

        class NeighCellSiAcquisitionParaR9
        {
        public:
            NeighCellSiAcquisitionParaR9();

            bool isIntraFreqSiAcqForHoR9Present_;
            IntraFreqSiAcqForHoR9 intraFreqSiAcqForHoR9_;

            bool isInterFreqSiAcqForHoR9Present_;
            InterFreqSiAcqForHoR9 interFreqSiAcqForHoR9_;

            bool isUtranSiAcqForHoR9Present_;
            UtranSiAcqForHoR9 utranSiAcqForHoR9_;
        };

        inline NeighCellSiAcquisitionParaR9::NeighCellSiAcquisitionParaR9():
        isIntraFreqSiAcqForHoR9Present_(false),
        intraFreqSiAcqForHoR9_(NUM_OF_INTRA_FREQ_SI_ACQ_FOR_HO_R9),
        isInterFreqSiAcqForHoR9Present_(false),
        interFreqSiAcqForHoR9_(NUM_OF_INTER_FREQ_SI_ACQ_FOR_HO_R9),
        isUtranSiAcqForHoR9Present_(false),
        utranSiAcqForHoR9_(NUM_OF_UTRAN_SI_ACQ_FOR_HO_R9)
        {            
        }

        class SonParametersR9
        {
        public:
            SonParametersR9();

            bool isSonParaRachReportR9Present_;
            SonParaRachReportR9 sonParaRachReportR9_;
        };

        inline SonParametersR9::SonParametersR9():
        isSonParaRachReportR9Present_(false),
        sonParaRachReportR9_(NUM_OF_SON_PARA_RACH_REPORT_R9)
        {
        }
        
        enum ERedirectionUtraR9
        {
            E_REDIRECTION_UTRA_R9_SUPPORTED = 0,
            NUM_OF_E_REDIRECTION_UTRA_R9,
            MIN_E_REDIRECTION_UTRA_R9 = E_REDIRECTION_UTRA_R9_SUPPORTED,
            MAX_E_REDIRECTION_UTRA_R9 = NUM_OF_E_REDIRECTION_UTRA_R9-1
        };

        enum ECsfb1xrttR9
        {
            E_CSFB_1XRTT_R9_SUPPOETED = 0,
            NUM_OF_E_CSFB_1XRTT_R9,
            MIN_OF_E_CSFB_1XRTT_R9 = E_CSFB_1XRTT_R9_SUPPOETED,
            MAX_OF_E_CSFB_1XRTT_R9 = NUM_OF_E_CSFB_1XRTT_R9-1
        };
        
        enum ECsfbConcpsMob1xrttR9
        {
            E_CSFB_CONCPS_MOB1XRTT_R9_SUPPORTED = 0,
            NUM_OF_E_CSFB_CONCPS_MOB1XRTT_R9,
            MIN_OF_E_CSFB_CONCPS_MOB1XRTT_R9 = E_CSFB_CONCPS_MOB1XRTT_R9_SUPPORTED,
            MAX_OF_E_CSFB_CONCPS_MOB1XRTT_R9 = NUM_OF_E_CSFB_CONCPS_MOB1XRTT_R9-1
        };
    
        class IratParametersCdma20001xrttV920
        {
        public:
            IratParametersCdma20001xrttV920();
      
            ECsfb1xrttR9  eCsfb1xrttR9_;
           
            bool isECsfbConcpsMob1xrttR9Present_;
            ECsfbConcpsMob1xrttR9   eCsfbConcpsMob1xrttR9_;            
        };
  
        inline IratParametersCdma20001xrttV920::IratParametersCdma20001xrttV920():
        eCsfb1xrttR9_(NUM_OF_E_CSFB_1XRTT_R9),
        isECsfbConcpsMob1xrttR9Present_(false),
        eCsfbConcpsMob1xrttR9_(NUM_OF_E_CSFB_CONCPS_MOB1XRTT_R9)        
        {
        }




        enum DeviceTypeR9
        {
            DEVICE_TYPE_R9_NO_BEN_FROM_BAT_CONSUMP_OPT = 0,
            NUM_OF_DEVICE_TYPE_R9,
            MIN_OF_DEVICE_TYPE_R9 = DEVICE_TYPE_R9_NO_BEN_FROM_BAT_CONSUMP_OPT,
            MAX_OF_DEVICE_TYPE_R9 = NUM_OF_DEVICE_TYPE_R9 - 1
        };

        typedef LteApp::R1::VariableContainer LateNonCriticalExtension;

        class UeEutraCapabilityV940Ies
        {
        public:
            UeEutraCapabilityV940Ies();

            bool isLateNonCriticalExtensionPresent_;
            LateNonCriticalExtension  lateNonCriticalExtension_;    
        };

        inline UeEutraCapabilityV940Ies:: UeEutraCapabilityV940Ies():
        isLateNonCriticalExtensionPresent_(false)
        {
        }


        class IratParameterUtraV920
        {
        public:
            IratParameterUtraV920();

            ERedirectionUtraR9   eRedirectionUtraR9_;             
        }; 
           
        inline IratParameterUtraV920::IratParameterUtraV920():
        eRedirectionUtraR9_(NUM_OF_E_REDIRECTION_UTRA_R9)
        {
        }
        
        
        class UeEutraCapabilityV920
        {
        public:
            UeEutraCapabilityV920();

            PhyLayerParametersV920 phyLayerParametersV920_;

            IratParametersGeranV920 iratParametersGeranV920_;

            bool isIratParametersUtraV920Present_;
            IratParameterUtraV920  iratParametersUtraV920_;            

            bool isIratParametersCdma20001xrtV920Present_; 
            IratParametersCdma20001xrttV920  iratParametersCdma20001xrttV920_;
            
            bool isDeviceTypeR9Present_;
            DeviceTypeR9 deviceTypeR9_;
            
            CsgProximityIndParaR9 csgProximityIndParaR9_;

            NeighCellSiAcquisitionParaR9 neighCellSiAcquisitionParaR9_;

            SonParametersR9 sonParametersR9_;
            
            bool isUeEutraCapabilityV940IesPresent_; 
            UeEutraCapabilityV940Ies ueUtraCapabilityV940Ies_;       
        };

        inline UeEutraCapabilityV920::UeEutraCapabilityV920():
        isIratParametersUtraV920Present_(false),
        isIratParametersCdma20001xrtV920Present_(false),
        isDeviceTypeR9Present_(false),
        deviceTypeR9_(NUM_OF_DEVICE_TYPE_R9),
        isUeEutraCapabilityV940IesPresent_(false)
        {            
        }

        class UeEutraCapability
        {
        public:
            UeEutraCapability();

            static const uint16_t MIN_UE_CATEGORY = 1;
            static const uint16_t MAX_UE_CATEGORY = 5;
            static const uint16_t SIZE_OF_FEATURE_GROUP_INDICATORS = 32;

            bool isUeFeatureSupported(UeFeature ueFeature);
            bool isUeFeatureSupported(UeFeature ueFeature, uint32_t featureGroupIndicators);

            AccessStratumRelease accessStratumRelease_;
            uint16_t ueCategory_;
            PdcpParameters pdcpParameters_;
            PhyLayerParameters phyLayerParameters_;
            RfParameters rfParameters_;
            MeasParameters measParameters_;
            bool isFeatureGroupIndicatorsPresent_;
            uint32_t featureGroupIndicators_;
            InterRatParameters interRatParameters_;

            bool isUeEutraCapabilityV920Present_;
            UeEutraCapabilityV920 ueEutraCapabilityV920_;
        };

        inline UeEutraCapability::UeEutraCapability():
        accessStratumRelease_(NUM_ACCESS_STRATUM_RELEASE),
        ueCategory_(MAX_UE_CATEGORY+1),
        isFeatureGroupIndicatorsPresent_(false),
        featureGroupIndicators_(0xffffffff),
        isUeEutraCapabilityV920Present_(false)
        {
        }

        inline bool UeEutraCapability::isUeFeatureSupported(UeFeature ueFeature)
        {
            return (isFeatureGroupIndicatorsPresent_ ? isUeFeatureSupported(ueFeature, featureGroupIndicators_) : true);
        }

        class EquivalentPlmnList
        {
        public:
            EquivalentPlmnList();
           
            static const uint16_t MIN_NUM_OF_EPLMN = 1;
            static const uint16_t MAX_NUM_OF_EPLMN = 15;

            uint16_t numOfEquivalentPlmn_;
            R1::PlmnIdType equivalentPlmnItem_[MAX_NUM_OF_EPLMN];
        };

        inline EquivalentPlmnList::EquivalentPlmnList():
        numOfEquivalentPlmn_(0)
        {
        }

        class ForbiddenTacsList
        {
        public:
            ForbiddenTacsList();

            static const uint16_t MIN_NUM_OF_FORB_TACS = 1;
            static const uint16_t MAX_NUM_OF_FORB_TACS = 4096;

            std::vector<Tac> forbiddenTacsItem_;
        };

        inline ForbiddenTacsList::ForbiddenTacsList()
        {
        }

        class ForbiddenTasItem
        {
        public:
            ForbiddenTasItem();

            R1::PlmnIdType plmnId_;
            ForbiddenTacsList forbiddenTacsList_;
        };

        inline ForbiddenTasItem::ForbiddenTasItem()
        {
        }

        class ForbiddenTasList
        {
        public:
            ForbiddenTasList();
           
            static const uint16_t MIN_NUM_OF_EPLMN_PLUS_ONE = 1;
            static const uint16_t MAX_NUM_OF_EPLMN_PLUS_ONE = 16;

            std::vector<ForbiddenTasItem> forbiddenTasItem_;
        };

        inline ForbiddenTasList::ForbiddenTasList()
        {
        }

        class ForbiddenLacsList
        {
        public:
            ForbiddenLacsList();
            
            static const uint16_t MIN_NUM_OF_FORB_LACS = 1;
            static const uint16_t MAX_NUM_OF_FORB_LACS = 4096;

            std::vector<Lac> forbiddenLacsItem_;
        };

        inline ForbiddenLacsList::ForbiddenLacsList()
        {
        }

        class ForbiddenLasItem
        {
        public:
            ForbiddenLasItem(); 

            R1::PlmnIdType plmnId_;
            ForbiddenLacsList forbiddenLacsList_;
        };

        inline ForbiddenLasItem::ForbiddenLasItem()
        {
        }

        class ForbiddenLasList
        {
        public:
            ForbiddenLasList();

            static const uint16_t MIN_NUM_OF_EPLMN_PLUS_ONE = 1;
            static const uint16_t MAX_NUM_OF_EPLMN_PLUS_ONE = 16;

            std::vector<ForbiddenLasItem> forbiddenLasItem_;
        };

        inline ForbiddenLasList::ForbiddenLasList()
        {
        }

        enum ForbiddenInterRats
        {
            ALL = 0,
            GERAN = 1,
            UTRAN = 2,
            CDMA2000 = 3,
            GERAN_AND_UTRAN = 4,
            CDMA2000_AND_UTRAN = 5,
            NUM_OF_FORBIDDEN_INTER_RATS,
            MIN_FORBIDDEN_INTER_RATS = ALL,
            MAX_FORBIDDEN_INTER_RATS = NUM_OF_FORBIDDEN_INTER_RATS - 1
        };

        class HandoverRestrictionList
        {
        public:
            HandoverRestrictionList();
            void reset();

            R1::PlmnIdType servingPlmnId_;

            bool isEquivalentPlmnsPresent_;
            EquivalentPlmnList equivalentPlmnList_;

            bool isForbiddenTasPresent_;
            ForbiddenTasList forbiddenTasList_;

            bool isForbiddenLasPresent_;
            ForbiddenLasList forbiddenLasList_;

            bool isForbiddenInterRatsPresent_;
            ForbiddenInterRats  forbiddenInterRats_;
        };

        inline HandoverRestrictionList::HandoverRestrictionList():
        isEquivalentPlmnsPresent_(false),
        isForbiddenTasPresent_(false),
        isForbiddenLasPresent_(false),
        isForbiddenInterRatsPresent_(false),
        forbiddenInterRats_(NUM_OF_FORBIDDEN_INTER_RATS)
        {
        }

    }//R1

}//LteApp

#endif
